第1关：类的定义

任务描述

本关任务：学会类的定义，完成以下任务：

1.定义类属性name类型为String，值为李四；定义类型age，类型为int，值为18

2.定义一个公有方法speak，返回值为空，方法体为输出打印“我爱学习”

要求：类名必须为Student，修饰符为public

相关知识

1.面向对象概述

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

提到面向对象，自然会想到面向过程，面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候依次调用就可以了。面向对象则是把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。当然，一个应用程序会包含多个对象，通过多个对象的相互配合来实现应用程序的功能，这样当应用程序功能发生变动时，只需要修改个别的对象就可以了，从而使代码更容易得到维护。面向对象的特点主要可以概括为封装性、继承性和多态性。

1、封装性

封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。例如，用户使用电脑，只需要使用手指敲键盘就可以了，无需知道电脑内部是如何工作的，即使用户可能碰巧知道电脑的工作原理，但在使用时，并不完全依赖电脑工作原理这些细节。

2、继承性

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。例如，有一个汽车的类，该类中描述了汽车的普通特性和功能，而轿车的类中不仅应该包含汽车的特性和功能，还应该增加轿车特有的功能，这时，可以让轿车类继承汽车类，在轿车类中单独添加轿车特性的方法就可以了。继承不仅增强了代码的复用性、提高开发效率，还为程序的维护补充提供了便利。

3、多态性

多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其它类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut” 这个单词时，理发师的行为是剪发，演员的行为表现是停止表演，不同的对象，所表现的行为是不一样的。

2. 类的定义

现实世界的事物有属性（人的身高，体重等）和行为（人可以学习，吃饭等）

Java中用class描述事物也是如此，成员变量 就是事物的属性，成员方法 就是事物的行为

定义类其实就是定义类的成员(成员变量和成员方法)

1. /**
2. 事物：
3. 属性 事物的信息描述
4. 行为 事物的功能
5. 类：
6. 成员变量 事物的属性
7. 成员方法 事物的行为
8. 定义一个类，其实就是定义该类的成员变量和成员方法。
9. 案例：我们来完成一个学生类的定义。
10. 学生事物：
11. 属性：姓名，年龄，地址...
12. 行为：学习，吃饭，睡觉...
13. 把事物要转换为对应的类：
14. 学生类：
15. 成员变量：姓名，年龄，地址...
16. 成员方法：学习，吃饭，睡觉...
17. 成员变量：和以前变量的定义是一样的格式，但是位置不同，在类中方法外。
18. 成员方法：和以前的方法定义是一样的格式，但是今天把static先去掉。
19. 首先我们应该定义一个类，然后完成类的成员。
20. */
21. //这是我的学生类
22. class Student {
23. //定义变量
24. String name;//姓名
25. int age;//年龄
26. String address;//地址
28. //定义方法
29. //学习的方法
30. public void study() {
31. System.out.println("学生爱学习");
32. }
34. //吃饭的方法
35. public void eat() {
36. System.out.println("学习饿了,要吃饭");
37. }
39. //睡觉的方法
40. public void sleep() {
41. System.out.println("学习累了,要睡觉");
42. }
43. }

编程要求

根据提示，在右侧编辑器补充代码，完成以下任务：

1.定义类属性name类型为String，值为李四；定义类型age，类型为int，值为18

2.定义一个公有方法speak，返回值为空，方法体为输出打印“我爱学习”

要求：类名必须为Student，修饰符为public

测试说明

无输入

代码如下 

package step1;
// ---------------------Begin------------------------
public class Student
{
    String name="李四";
    int age=18;
    public void speak()
    {
        System.out.println("我爱学习");
    }
}
// ---------------------End------------------------

---

第2关：类构造方法与this关键字

任务描述

本关任务： 定义Student类，完成3个构造方法的属性

类属性有name，String类型；age，int类型。修饰符均为private（私有）

1.定义无参构造方法

2.定义有参构造方法，接受一个Sring类型的参数，完成对Student类中的name属性赋值

3.定义有参构造方法，接受一个int类型的参数，完成对Student类中的age属性赋值

4.定义有参构造方法，接受两个参数，完成对Student类中的name属性和age属性赋值

相关知识

1. 构造方法

构造方法作用概述：给对象的数据进行初始化

构造方法格式

• 方法名与类名相同
• 没有返回值类型，连void都没有
• 没有具体的返回值

构造方法注意事项

• 如果你不提供构造方法，系统会给出默认构造方法
• 如果你提供了构造方法，系统将不再提供
• 构造方法也是可以重载的

给成员变量赋值有两种方式

• setXxx()
• 构造方法

PS：

1. 一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。 一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用并且只调用一次。 一般函数：对象创建后，可以被调用多次。

1. 创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

1. 多个构造函数是以重载的形式存在的。
2. /**
3. 我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?
5. 构造方法的注意事项:
6. A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
7. B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
8. 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
10. 给成员变量赋值有两种方式：
11. A:setXxx()
12. B:构造方法
13. */
15. class Student {
16. private String name;
17. private int age;
19. public Student() {
20. //System.out.println("我给了，你还给不");
21. System.out.println("这是无参构造方法");
22. }
24. //构造方法的重载格式
25. public Student(String name) {
26. System.out.println("这是带一个String类型的构造方法");
27. this.name = name;
28. }
30. public Student(int age) {
31. System.out.println("这是带一个int类型的构造方法");
32. this.age = age;
33. }
35. public Student(String name,int age) {
36. System.out.println("这是一个带多个参数的构造方法");
37. this.name = name;
38. this.age = age;
39. }
41. public void show() {
42. System.out.println(name+"---"+age);
43. }
44. }

2 this关键字

this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。

当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用。

简单说，哪个对象调用了this所在的函数，this就代表哪个对象。一般方法调用默认加this。（方法被哪个对象调用，this就代表那个对象）

什么时候使用this呢?

• 局部变量隐藏成员变量

  1. /**
  2. 我们曾经曰：起名字要做到见名知意。
  4. this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。
  6. 注意：谁调用这个方法，在该方法内部的this就代表谁。
  8. this的场景：
  9. 解决局部变量隐藏成员变量
  11. this:哪个对象调用那个方法，this就代表那个对象
  12. */
  13. class Student {
  14. private String name;
  15. private int age;
  17. public String getName() {
  18. return name; //这里其实是隐含了this
  19. }
  21. public void setName(String name) {
  22. this.name = name;
  23. }
  25. public int getAge() {
  26. return age;
  27. }
  29. public void setAge(int age) {
  30. this.age = age;
  31. }
  32. }

编程要求

根据提示，在右侧编辑器补充代码，完成以下任务：

1.定义无参构造方法

2.定义有参构造方法，接受一个Sring类型的参数，完成对Student类中的name属性赋值

3.定义有参构造方法，接受一个int类型的参数，完成对Student类中的age属性赋值

4.定义有参构造方法，接受两个参数，完成对Student类中的name属性和age属性赋值

相关知识

测试说明

平台会对你编写的代码进行测试：

无输入

代码如下

package step2;
public class Student 
{
    // ---------------------Begin------------------------
    private int age;
    private String name;
    public Student(String name)
    {
        this.name=name;
    }
    public Student(int age)
    {
        this.age=age;
    }
    public Student(int age,String name)
    {
        this.age=age;
        this.name=name;
    }
    public Student(){}
    // ---------------------End------------------------
    @Override
    public String toString() 
    {
        return String.format("大家好我叫：%s，今年：%d岁", this.name, this.age);
    }
}

---

第3关：类方法的重载

任务描述

本关任务：完成Caculator类中getArea方法的重载

1.重载1：接受两个double类型的参数，方法返回两参数的乘积

2.重载2：接受3个double类型的参数，方法返回3个参数的乘积

相关知识

1.方法重载存在的意义

在同一个类中，可以有多个不同的方法，方法名也就非常多，在使用时就需要大量的记忆不同的方法名。而方法重载的意义就在于让方法使用相同的方法名，再各自使用自己的形参，最终在用户使用时，系统就可以根据用户输入的数据的类型进行方法的匹配，避免了使用者需要记忆大量的方法名。

2.什么是方法重载？

在一个类中，方法名相同，参数不同（这里的不同指，参数个数不同，参数类型不同以及参数传入顺序不同），构成方法重载。

方法重载与访问修饰符，返回值类型，方法参数的名字都没有关系。

3.方法重载的作用

让使用者可以更方便的调用类中的方法。

4.方法重载的特点

1.方法名相同

2.参数列表不同（个数、类型、次序）

例如上一个的多个构造方法就构成了方法的重载：

1. class Student {
2. private String name;
3. private int age;
5. public Student() {
6. //System.out.println("我给了，你还给不");
7. System.out.println("这是无参构造方法");
8. }
10. //构造方法的重载格式
11. public Student(String name) {
12. System.out.println("这是带一个String类型的构造方法");
13. this.name = name;
14. }
16. public Student(int age) {
17. System.out.println("这是带一个int类型的构造方法");
18. this.age = age;
19. }
21. public Student(String name,int age) {
22. System.out.println("这是一个带多个参数的构造方法");
23. this.name = name;
24. this.age = age;
25. }
27. public void show() {
28. System.out.println(name+"---"+age);
29. }
30. }

编程要求

根据提示，在右侧编辑器补充代码，完成Caculator类中getArea方法的重载

1.重载1：接受两个double类型的参数，方法返回两参数的乘积

2.重载2：接受3个double类型的参数，方法返回3个参数的乘积

测试说明

平台会对你编写的代码进行测试：

无输入

代码如下

package step3;
public class Caculator 
{

    public double getArea(double a)
    {
        return a*a;
    }
    // ---------------------Begin------------------------
    public double getArea(double a,double b)
    {
        return a*b;
    } 
    public double getArea(double w,double h,double l)
    {
        return w*h*l;
    } 
    // ---------------------End------------------------
}

---

第4关：getter与setter方法

任务描述

本关任务：编写Student的getter和setter方法，实现对相应的属性进行合法限制

1.setAge方法，假定合法范围为0-120，不符合此范围内则设置为18

2.setSex方法，判断参数是否为“男”或者“女”，否则设置为：“保密”

相关知识

封装数据，对私有属性进行封装，只是暴露出public方法来访问

1. setter方法

1.可以限制和检验setter方法传入的参数
2.隐藏对象内部数据结构
3.保持对象在每个状态的完整性

2. getter方法

1.按照客户的期望返回格式化数据
2.控制服务的顺序(例如只有当连接建立时getter方法才返回相应实例

一个标准的案例的使用

1. /**
2. 封装和private的应用：
3. A:把成员变量用private修饰
4. B:提高对应的getXxx()和setXxx()方法
5. */
6. //定义学生类
7. class Student {
8. //姓名
9. private String name;
10. //年龄
11. private int age;
13. //姓名获取值
14. public String getName() {
15. return name;
16. }
18. //姓名设置值
19. public void setName(String n) {
20. name = n;
21. }
23. //年龄获取值
24. public int getAge() {
25. return age;
26. }
27. public String getName() {
28. return name;
29. }
30. //年龄赋值
31. public void setAge(int a) {
32. age = a;
33. }
34. }
36. //测试类
37. class StudentTest {
38. public static void main(String[] args) {
39. //创建学生对象
40. Student s = new Student();
42. //使用成员变量
43. //错误：被私有修饰了，外界不能直接访问了
44. //System.out.println(s.name+"---"+s.age);
45. System.out.println(s.getName()+"---"+s.getAge());
47. //给成员变量赋值
48. //s.name = "林青霞";
49. //s.age = 27;
50. //通过方法给赋值
51. s.setName("林青霞");
52. s.setAge(27);
53. System.out.println(s.getName()+"---"+s.getAge());
54. }
55. }

编程要求

根据提示，在右侧编辑器补充代码，编写Student的getter和setter方法，实现对相应的属性进行合法限制

1.setAge方法，假定合法范围为0-120，不符合此范围内则设置为18

2.setSex方法，判断参数是否为“男”或者“女”，否则设置为：“保密”

测试说明

平台会对你编写的代码进行测试：

测试输入：

李四

无

-12

预期输出：

代码如下 

package step4;
public class Student 
{
   private int age;
    private String name;
   private String sex;
    // ---------------------Begin------------------------
    public int getAge() 
    {
        return age;
    }
    public void setAge(int age) 
    {
        if (age <0 || age >120)
            this.age = 18;
        else
        {
            this.age = age;
        }
    }
    public String getName() 
    {
        return name;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public String getSex() 
    {
        return sex;
    }
    public void setSex(String sex) 
    {
        if(sex.equals("男") || sex.equals("女"))
        {
            this.sex = sex;
        }
        else 
        {
            this.sex = "保密";
        }
    }
    // ---------------------End------------------------
    @Override
    public String toString() 
    {
        return String.format("大家好，我叫：%s,性别：%s，今年：%d", this.name, this.sex,this.age);
    }
}

---

第5关：static关键字

任务描述

本关任务：掌握static关键字的使用及类初始化的顺序

1.定义类静态代码块：打印输出“类静态代码块被调用”

2.定义方法名为：sayHello的静态方法，方法体为打印输出“静态方法被调用 ”

3.定义静态类属性name，类型为String，值为：张三

相关知识

1. static关键字

static关键字可以修饰成员变量和成员方法

2. static关键字特点

• 随着类的加载而加载
• 优先于对象存在
• 被类的所有对象共享
• 这也是我们判断是否使用静态关键字的条件
• 可以通过类名调用

3. static关键字注意事项

• 在静态方法中是没有this关键字的
• 静态方法只能访问静态的成员变量和静态的成员方法

静态的内存图

静态变量和成员变量的区别

4. main方法是静态的

public static void main(String[] args) {}

• public 被jvm调用，访问权限足够大。
• static 被jvm调用，不用创建对象，直接类名访问
• void被jvm调用，不需要给jvm返回值
• main 一个通用的名称，虽然不是关键字，但是被jvm识别
• String[] args 以前用于接收键盘录入的
• 静态什么时候用？

4.1 静态变量

当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。

只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

4.2 静态函数

函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。

简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用。

编程要求

根据提示，在右侧编辑器补充代码，完成以下任务：

1.定义类静态代码块：打印输出“类静态代码块被调用”

2.定义方法名为：sayHello的静态方法，方法体为打印输出“静态方法被调用 ”

3.定义静态类属性name，类型为String，值为：张三

测试说明

平台会对你编写的代码进行测试：

无输入

预期输出：

类静态代码块被调用 张三 静态方法被调用

代码如下

package step5;

public class StaticLearning 
{
    // ---------------------Begin------------------------
    static String name = "张三";
	static
	{
		System.out.println("类静态代码块被调用");
	}
	public static void main(String[] args) 
    {
		System.out.println( name);
	}
	
	public static void sayHello()
    {
		System.out.println("静态方法被调用");
    }
    // ---------------------End------------------------
}

---

第6关：知识回顾

任务描述

本关任务：对本章主要理论知识点进行回顾复习。

相关知识

为了完成本关任务，你需要对之前完成的关卡进行复习。

编程要求

根据相关知识，按照要求完成选择题任务，包含单选题和多选题。

测试说明

平台会对你选择的答案进行判断，全对则通过测试。

• 1、

  面向对象的核心思想为（）

  A、

  多态

  B、

  封装

  C、

  继承

  D、

  多线程

• 2、

  下列说法正确的是（）

  A、

  在类方法中只能调用本类中的类方法

  B、

  在类方法中调用本类的类方法时可直接调用

  C、

  在类方法中可用this来调用本类的类方法

  D、

  在类方法中绝对不能调用实例方法

• 3、

  Java方法的重载的规则，下面正确的是（）

  A、

  方法名必须不同 参数列表必须不同

  B、

  方法名必须不同 参数列表必须相同

  C、

  方法名必须相同 参数列表必须相同

  D、

  方法名必须相同 参数列表必须不同

• 4、

  static关键字的特点有（）

  A、

  随着类的加载而加载

  B、

  可以通过类名调用

  C、

  这也是我们判断是否使用静态关键字的条件

  D、

  被类的所有对象共享

  E、

  优先于对象存在

答案如下

---

1.B

2.B

3.D

4.BCDE

---