Fork me on GitHub

Java基础

快捷键

eclipse快捷键的使用

列编辑功能

要使用 Eclipse 的列编辑功能,只需要通过快捷键Alt+Shift+A 进入列编辑模式,修改完成后,再按一次 Alt+Shift+A 退出列编辑模式。
有了列编辑功能,就可以对一块代码进行编辑了:
比如一块代码的缩进,只需要选中代码块按Tab就可以了;
又比如想在每行第二个字符前加入一个“test”,那么只需要向下拖动光标,使定位在每行的第二个字符,然后就可以插入啦。

引入包(import)

Ctrl+Shift+O
引入所使用的全部包

格式化代码

Ctrl+Shift+F
主要用于使代码排列整齐

保存

Ctrl+S

保存所有

Ctrl+Shift+S

搜索对话框

Ctrl+H

Eclipse全局搜索使用方法

  • 使用快捷键“ctrl+H”打开文件搜索对话框,选择“File Search”标签,在Containing text中输入你需要搜索的字符串,在Scope中,选择你要搜索的范围,点击Search
  • 双击进入查看

    打开资源

    Ctrl+Shift+R

    打开类型

    Ctrl+Shift+T

    补全代码

    Alt+/
    该快捷键常用于使用方法时,只需要部分字母即可自动联想。比如想要得到str.length()时只要输入str.l即可找到

    删除行

    Ctrl+D

    上下移动选中的行

    Alt+Up/Down

    后退

    Ctrl+Z

    前进

    Ctrl+Y

    添加注释

    Ctrl+/
    选中内容注释: Ctrl+Shift+/

    Debug

    1
    2
    3
    4
    5
    F5:Step Into(debug
    F6:Step over(debug
    F7:Step returndebug
    F8:Resume(debug
    F11:debug上一个应用(debug

快速修正

Ctrl+1
用于

  • 某个类有了方法签名,但没有该方法时的快速创建
  • 有异常需要抛出或者trycatch时
  • 其他等等

进入某个类或方法

Ctrl+鼠标左键

缩进(制表符)

Tab
用于缩进,可选中多行缩进

左移缩进

Shift + Tab
可选中多行向左缩进

剪切

Ctrl+X

复制

Ctrl+C

粘贴

Ctrl+V

后端相关

可变长参数的使用和注意事项

可变长参数表示

使用…表示可变长参数,例如:

1
2
3
4
5
print(String... args){
...
}

在具有可变长参数的方法中可以把参数当成数组使用,例如可以循环输出所有的参数值。

1
2
3
4
5
6
7
print(String... args){
for(String temp:args)
System.out.println(temp);
}

可变长参数的方法的调用

调用的时候可以给出任意多个参数也可不给参数,例如:

1
2
3
4
5
6
7
print();
print("hello");
print("hello","lisi");
print("hello","张三", "alexia")

可变长参数的使用规则

在调用方法的时候,如果能够和固定参数的方法匹配,也能够与可变长参数的方法匹配,则选择固定参数的方法。看下面代码的输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com;
// 这里使用了静态导入
import static java.lang.System.out;
public class VarArgsTest {
public void print(String... args) {
for (int i = 0; i < args.length; i++) {
out.println(args[i]);
}
}
public void print(String test) {
out.println("----------");
}
public static void main(String[] args) {
VarArgsTest test = new VarArgsTest();
test.print("hello");
test.print("hello", "alexia");
}
}

输出:

1
2
3
----------
hello
alexia

如果要调用的方法可以和两个可变参数匹配,则出现错误,例如下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com;
// 这里使用了静态导入
import static java.lang.System.out;
public class VarArgsTest1 {
public void print(String... args) {
for (int i = 0; i < args.length; i++) {
out.println(args[i]);
}
}
public void print(String test,String...args ){
out.println("----------");
}
public static void main(String[] args) {
VarArgsTest1 test = new VarArgsTest1();
test.print("hello");
test.print("hello", "alexia");
}
}

对于上面的代码,main方法中的两个调用都不能编译通过,因为编译器不知道该选哪个方法调用,如下所示:

一个方法只能有一个可变长参数,并且这个可变长参数必须是该方法的最后一个参数
以下两种方法定义都是错误的。

1
2
3
4
5
6
7
public void test(String... strings,ArrayList list){
}
public void test(String... strings,ArrayList... list){
}

可变长参数的使用规范

  • 避免带有可变长参数的方法重载:如上述中,编译器虽然知道怎么调用,但人容易陷入调用的陷阱及误区

  • 别让null值和空值威胁到变长方法,为了说明null值的调用,重新给出一个例子:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package com;public class VarArgsTest1 {
    public void print(String test, Integer... is) {
    }
    public void print(String test,String...args ){
    }
    public static void main(String[] args) {
    VarArgsTest1 test = new VarArgsTest1();
    test.print("hello");
    test.print("hello", null);
    }
    }

这时会发现两个调用编译都不通过:

因为两个方法都匹配,编译器不知道选哪个,于是报错了,这里同时还有个非常不好的编码习惯,即调用者隐藏了实参类型,这是非常危险的,不仅仅调用者需要“猜测”该调用哪个方法,而且被调用者也可能产生内部逻辑混乱的情况。对于本例来说应该做如下修改:

1
2
3
4
5
public static void main(String[] args) {
VarArgsTest1 test = new VarArgsTest1();
String[] strs = null;
test.print("hello", strs);
}

  • 覆写变长方法也要循规蹈矩
    下面这个例子,编译不通过
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    package com;
    public class VarArgsTest2 {
    /**
    * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    // 向上转型
    Base base = new Sub();
    base.print("hello");
    // 不转型
    Sub sub = new Sub();
    sub.print("hello");
    }
    }
    // 基类
    class Base {
    void print(String... args) {
    System.out.println("Base......test");
    }
    }
    // 子类,覆写父类方法
    class Sub extends Base {
    @Override
    void print(String[] args) {
    System.out.println("Sub......test");
    }
    }


第一个能编译通过,这是为什么呢?事实上,base对象把子类对象sub做了向上转型,形参列表是由父类决定的,当然能通过。而看看子类直接调用的情况,这时编译器看到子类覆写了父类的print方法,因此肯定使用子类重新定义的print方法,尽管参数列表不匹配也不会跑到父类再去匹配下,因为找到了就不再找了,因此有了类型不匹配的错误。
这是个特例,覆写的方法参数列表竟然可以与父类不相同,这违背了覆写的定义,并且会引发莫名其妙的错误。
这里,总结下覆写必须满足的条件:

  • 重写方法不能缩小访问权限;
  • 参数列表必须与被重写方法相同(包括显示形式);
  • 返回类型必须与被重写方法的相同或是其子类;
  • 重写方法不能抛出新的异常,或者超过了父类范围的异常,但是可以抛出更少、更有限的异常,或者不抛出异常。

    可变长参数相对于数组的优势

    貌似只有:可以避免定义数组的麻烦

    Map遍历的方法

    第一种,普遍使用,二次取值

    1
    2
    3
    4
    //通过Map.keySet遍历key和value
    for (String key : map.keySet()) {
    System.out.println("key= "+ key + " and value= " + map.get(key));
    }

第二种

1
2
3
4
5
6
//通过Map.entrySet使用iterator遍历key和value
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

第三种,推荐,尤其是容量大时

1
2
3
4
//通过Map.entrySet遍历key和value
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

第四种

1
2
3
4
5
//通过Map.values()遍历所有的value,但不能遍历key
for (String v : map.values()) {
System.out.println("value= " + v);
}
}

Java虚拟机内存设置

Java虚拟机的堆大小如何设置:命令行
 java –Xms128m //JVM占用最小内存
–Xmx512m //JVM占用最大内存
–XX:PermSize=64m //最小堆大小
–XX:MaxPermSize=128m //最大堆大小
递归调用可以导致栈(Stack)溢出
不断创建对象可以导致堆(Heap)溢出(对象存在堆中)

前端相关

src和href区别

src是引入,是页面必不可少的一部分,用于替换当前元素,如img、script、iframe等元素上使用;href是引用,是与该页面有关联,用于在当前文档和引用资源之间确立联系,如link和a等标签上使用。
src是source的缩写,指向外部资源的位置,指向的内容将会嵌入到文档中当前标签所在位置;在请求src资源时会将其指向的资源下载并应用到文档内,例如js脚本,img图片和iframe等元素。当浏览器解析到该元素时,会暂停其他资源的下载和处理,直到将该资源加载、编译、执行完毕,图片和框架等元素也如此,类似于将所指向资源嵌入当前标签内。这也是为什么将js脚本放在底部而不是头部。
href是Hypertext Reference的缩写,指向网络资源所在位置,建立和当前元素(锚点)或当前文档(链接)之间的链接。

「真诚赞赏,手留余香」