快捷键积累

Ctrl + D 复制当前行到下一行

Ctrl + 鼠标左键对准需要查看的类 进入该类的源码

100.for + 回车

等于

for (i=0;i<100;i++){

}

前提:先打断点

Shift + F9 进入debug

F7 跳至下一步

增强for 循环 快捷方式 : 数组名.for +回车

自制 Shift 和 + (取代Alt+Insrrt)

Alt + Insert get/set 方法快捷键

Alt + Insert 构造器快捷键

Alt Insert 选择Override Methods 重写快捷键

Ctrl + O 重写快捷键

自制 Ctrl+Shift+S 快速进入设置(取代Ctrl + Alt + S)

Ctrl + Alt + S 快速进入设置

SHFIT + F6 修改类名

SHFIT + F6 +选中需要修改的单词 可以批量修改代码中重复出现的单词

选中要捕获异常的代码 Ctrl +Alt +T 捕获异常快捷键

1.参数的传递

(1)实参传递:可以是实际的数;也可以是赋了值的变量名(普通变量/数组变量)

若int a=1; int a=sc.nextInt; int[ ] arrays={1,2,3,4}

则传参 要调用的方法名 (1) ; 要调用的方法名(a) ; 要调用的方法名(arrays)都可以

(2)形参规定写法:变量类型 变量名(可以按需求取名也可使用同一个) 但变量类型必须要与将传递进来的实参类型一致

方法名(int a) 方法名(int[ ] arrays) 都可以 解释:int [ ] 是数组类型

2.了解break,contiue;goto

代码见真知

运行结果

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
我是Vis.Yang

运行结果

1
2
3
4
5
6
7
8
9
11
12
13
14
15
16
17
18
19
21
22
23
24
25
26
27
28
29
31
32
33
34
35
36
37
38
39
41
42
43
44
45
46
47
48
49

了解goto

老规矩看代码😎

运行结果

101 103 107 109 113 127 131 137 139 149

3.static

一句话总结:非静态的属性和方法不能直接通过类名访问

方法中未加static,则必须New对象才能使用 必须!

一个个类实质上就是一个个对象

方法中加了static,那么既可以New对象使用

1.空(void) 对象.方法名(有参放参);

2.非空 变量类型 变量名(按需取名) =对象.方法名(有参放参);

方法中加了static,那么也可以不New对象使用

1.类名.方法名(有参放参);

在他处使用非本类写的加了static的方法

1.使用非本类的类名.方法名(有参放参);

2.或者New对象 对象.方法名(有参放参);

看代码😍

在他处使用非本类写的未加static的方法

必须New对象 (实例化他类) 使用对象.方法名(有参放参);

实例化:

对象类型 对象名 =对象值

看代码😀

本处类里写本处方法加static

1.可直接调用 方法名(有参放参) ;

2.也可加上本处类名 类名.方法名(有参放参);

3.还可以New对象 对象.方法名(有参放参);

本处类里写本处方法未加static

1.不可可直接调用 必须New对象 对象.方法名(有参放参);

4.return放哪?

必须在方法语句的括号的末括号上面

示例

5.多维数组

静态初始化

动态初始化

6.多维数组遍历

数组里外长度一致(行列数相同) 两种都可以,不会数组下标越界

普通for循环1 (容易出bug) 要细!

普通for循环2(采用这种就不会有问题) 少bug

数组里外长度不等(行列数不相同) 这样使用自然会数组下标越界 要细! 重要!

增强for循环(省略按下标遍历)

深入main方法

main方法是用于启动程序的,其实真正一个程序只有一个main方法,并不会像我们测试的那样,每个类里都有一个main方法,只是为让我们执行代码的时候方便

创建对象内存分析

访问修饰符

继承的类可直接使用父类get方法获得值

package com.demo.rj0315;
public class A {
    private String name;
    private String id;
    private double salary;
    public A() {
        super();
    }
    public A(String name, String id, double salary) {
        super();
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void work() {
        System.out.println("name=" + name + "id=" + id + "salary=" + salary);
    }
    @Override
    public String toString() {
        return "A [name=" + name + ", id=" + id + ", salary=" + salary + "]";
    }
}

package com.demo.rj0315;
public class B extends A {
private int bonus;
public B() {
super();
}
public B(String name, String id, double salary, int bonus) {
super(name, id, salary);
this.bonus = bonus;
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("name=" + getName() + "id=" + getId() + "salary=" + getSalary() + "bonus" + bonus);
}
@Override
public String toString() {
return "B [ name=" + getName() + "," + " id=" + getId() + ", " + "Salary=" + getSalary()
+ "bonus=" + bonus + "]";
}
}

package com.demo.rj0315;
public class Test {
public static void main(String[] args) {
A a = new A();
a.setName("xxx");
a.setId("123");
a.setSalary(20.0);
a.work();
System.out.println(a.toString());
B b = new B();
b.setName("xx");
b.setId("1234");
b.setSalary(30.0);
b.setBonus(50);
b.work();
System.out.println(b.toString());
}
}

运行结果:
name=xxxid=123salary=20.0
A [name=xxx, id=123, salary=20.0]
name=xxid=1234salary=30.0bonus50
B [ name=xx, id=1234, Salary=30.0bonus=50]