JavaSE基础之（十六）final关键字

16.1

16.2

16.3

引用类型的使用步骤

导包
使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。格式：

import 包名.类名
1
举例：

java.util.Scanner;
1
创建对象
使用该类的构造方法，创建一个该类的对象。 格式：

数据类型 变量名 = new 数据类型(参数列表);
1
举例：

Scanner sc = new Scanner(System.in);
1
调用方法
调用该类的成员方法，完成指定功能。格式：

变量名.方法名();
1
举例：

int i = sc.nextInt();//接受一个键盘录入的整数
1
引用类型用法总结

基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类 型也是可以的。

class作为成员变量
类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。

/**

• 武器类
  /
  public class Weapon {
  String name;//武器名称
  int hurt;//伤害值
  public String getName() {
  return name;
  }
  public void setName(String name) {
  this.name = name;
  }
  public int getHurt() {
  return hurt;
  }
  public void setHurt(int hurt) {
  this.hurt = hurt;
  }
  public Weapon(String name, int hurt) {
  this.name = name;
  this.hurt = hurt;
  }
  }
  /*
• 角色类
  /
  public class Role {
  String name;
  int id;
  //添加武器属性(武器类作为成员变量)
  Weapon weapon;
  public String getName() {
  return name;
  }
  public void setName(String name) {
  this.name = name;
  }
  public int getId() {
  return id;
  }
  public void setId(int id) {
  this.id = id;
  }
  public Weapon getWeapon() {
  return weapon;
  }
  public void setWeapon(Weapon weapon) {
  this.weapon = weapon;
  }
  //定义攻击的方法
  public void attrack(Weapon weapon){
  System.out.println(“使用”+weapon.getName()+“, 造成”+weapon.getHurt()+“点伤害”);
  }
  }
  /*
• 测试类
  */
  public class test {
  public static void main(String[] args) {
  //创建武器对象
  Weapon weapon = new Weapon(“大炮”,2);
  //创建角色对象
  Role role = new Role();
  //调用攻击方法
  role.attrack(weapon);
  }
  }
  输出结果：
  使用大炮, 造成2点伤害

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
interface作为成员变量

我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

/**

• 技能接口
  /
  public interface Skills {
  public abstract void Attrack();
  }
  /*
• 角色类
  /
  public class Role2 {
  Skills skills;
  public Skills getSkills() {
  return skills;
  }
  public void setSkills(Skills skills) {
  this.skills = skills;
  }
  // 法术攻击
  public void SkillAttack(){
  System.out.print(“发动法术攻击:”);
  skills.Attrack();
  System.out.println(“攻击完毕”);
  }
  }
  /*
• 测试类
  */
  public class test {
  public static void main(String[] args) {
  //创建角色对象
  Role2 role2 = new Role2();
  //重写接口中的方法
  role2.setSkills(new Skills() {
  @Override
  public void Attrack() {
  System.out.println(“正在法术攻击”);
  }
  });
  role2.SkillAttack();
  }
  }
  输出结果：
  发动法术攻击:正在法术攻击
  攻击完毕

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
35
36
37
38
39
40
41
42
43
44
interface作为方法参数和返回值类型
接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。
10.2 匿名对象
匿名对象

没有变量名的对象。 创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限。

格式：

new 类名(参数列表);
1
举例：

new Scanner(System.in);
1
应用场景

创建匿名对象直接调用方法，没有变量名。
new Scanner(System.in).nextInt();
1
一旦调用两次方法，就是创建两个对象，造成浪费。
new Scanner(System.in).nextInt();
new Scanner(System.in).nextInt();
1
2
小贴士：
一个匿名对象，只能使用一次。

匿名对象可以作为方法的参数和返回值。

作为参数

public class demo1 {
public static void main(String[] args) {
//普通方式
Scanner sc = new Scanner(System.in);
input(sc);
//匿名对象作为方法接收的参数
input(new Scanner(System.in));
}
public static void input(Scanner sc){
System.out.println(sc);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
作为返回值

public class demo3 {
public static void main(String[] args) {
//普通方式
Scanner sc = getScanner();
}
public static Scanner getScanner(){
//普通方式
Scanner sc = new Scanner(System.in);
return sc;
//匿名对象作为方法返回值
return new Scanner(System.in);
}