第一关
任务描述
本关任务：构造一个类，把对象的属性封装起来，同时提供一些可以被外界访问属性的方法。
相关知识
为了完成本关任务，你需要掌握：
1.什么是封装；
2.封装的意义；
3.实现Java封装的步骤。
什么是封装
封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装时的权限控制符区别如下:
封装的意义
对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处：
- 良好的封装能够减少耦合。
- 类内部的结构可以自由修改。
- 可以对成员进行更精确的控制。
- 隐藏信息，实现细节。
封装把一个对象的属性私有化，同时提供一些可以被外界访问属性的方法，如果不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
实现封装的步骤
- 修改属性的可见性来限制对属性的访问（一般限制为
private ），例如：
public class Person{
private String name;
private int age;
}
这段代码中，将
2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：
/*
*封装演示
*/
public class Person {
/*
* 对属性的封装 一个人的姓名、性别和年龄都是这个人的私有属性
*/
private String name;
private String sex;
private int age;
/*
* setter()、getter()是该对象对外开放的接口
*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
采用
封装可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码，就可以对成员变量进行更精确的控制。
public void setAge(int age) {
if (age > 120) {
System.out.println("ERROR：error age input...."); // 提示错误信息
} else {
this.age = age;
}
}
public String getSexName() {
if ("0".equals(sex)) {
sexName = "女";
} else if ("1".equals(sex)) {
sexName = "男";
} else {
sexName = "人妖";
}
return sexName;
}
编程要求
根据提示，在右侧编辑器Begin-End处补充代码：
- 声明一个Person类，私有化属性name和age，并将字段封装起来；
- 在Person类中定义一个talk()方法，打印姓名和年龄信息；
- 在main方法中声明并实例化一Person对象p，给p中的属性赋值，调用talk()方法打印 我是：张三，今年：18岁。
测试说明
测试输入：无
预期输出：
我是：张三，今年：18岁
实现代码：
package case1;
public class TestPersonDemo {
public static void main(String[] args) {
/********* begin *********/
// 声明并实例化一Person对象p
Person p = new Person();
// 给p中的属性赋值
p.getName(); //不用写
p.setName("张三");
p.getAge(); //不用写
p.setAge(18);
// 调用Person类中的talk()方法
p.talk();
/********* end *********/
}
}
// 在这里定义Person类
class Person {
/********* begin *********/
private static String name;
private static int age;
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public static void talk(){
System.out.println("我是："+name+"，今年："+age+"岁");
}
/********* end *********/
}
实验分析
- 封装把一个对象的属性私有化，同时提供一些可以被外界访问属性的方法。（get() 和set()）
- set() ：向外部提供设置属性的set方法
- get() ：向外部提供访问属性的get方法
参考链接
- 属性私有化后，不能被其他类直接使用修改，即
Person p = new Person(); p.name = "张三"; //这样是不允许的。name是Person类的私有变 量，不能再别的类中修改 p.setName("张三"); //只能通过调用setName()方法来修改name的值。因为setName是在Person类中的方法 - static的使用
静态方法中不能使用非静态变量，因为静态方法不能实例化。
出错代码：
package case1;
public class TestPersonDemo {
public static void main(String[] args) {
/********* begin *********/
// 声明并实例化一Person对象p
Person p = new Person();
// 给p中的属性赋值
p.getName(); //不用写
p.setName("张三");
p.getAge(); //不用写
p.setAge(18);
// 调用Person类中的talk()方法
p.talk();
/********* end *********/
}
}
// 在这里定义Person类
class Person {
/********* begin *********/
private String name; //此处是非静态变量
private int age; //此处是非静态变量
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public static void talk(){ //静态方法
System.out.println("我是："+name+"，今年："+age+"岁");
}
/********* end *********/
}
此例中，talk()是静态方法，而name 和 age是非静态变量，会出错
src/case1/TestPersonDemo.java:42: error: non-static variable name cannot be referenced from a static context
System.out.println("我是："+name+"，今年："+age+"岁");
第2关：什么是继承，怎样使用继承
任务描述
本关任务：掌握继承的基本概念以及怎么使用继承。
相关知识
为了完成本关任务，你需要掌握：1.继承的基本概念；2.继承的特性；3.子类对象的实例化过程。
继承的基本概念
所谓继承：是指可以让某个类型的对象获得另一个类型的对象的属性的方法.
兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
所以继承需要符合的关系是：is-a，父类更通用，子类更具体。
虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
在讲解继承的基本概念之前，读者可以先想一想这样一个问题：现在假设有一个Person类，里面有name与age两个属性，而另外一个Student类，需要有name、age、school三个属性，如图所示，从这里可以发现Person中已经存在有name和age两个属性，所以不希望在Student类中再重新声明这两个属性，这个时候就需要考虑是不是可以将Person类中的内容继续保留到Student类中，也就是引出了接下来所要介绍的类的继承概念。
在这里希望Student类能够将 Person类的内容继承下来后继续使用：
Java类的继承，可用下面的语法来表示：
class 父类 // 定义父类
{
...
}
class 子类 extends 父类 // 用extends关键字实现类的继承
{
...
}
范例：
public class TestPersonStudentDemo {
public static void main(String[] args) {
Student s = new Student();
// 访问Person类中的name属性
s.name = "张三";
// 访问Person类中的age属性
s.age = 18;
// 访问Student类中的school属性
s.school = "哈佛大学";
System.out.println("姓名：" + s.name + "，年龄：" + s.age + "，学校：" + s.school);
}
}
class Person {
String name;
int age;
}
class Student extends Person {
String school;
}
输出结果:
姓名：张三，年龄：18，学校：哈佛大学
由上面的程序可以发现，在Student类中虽然并未定义name与age属性，但在程序外部却依然可以调用name或age，这是因为Student类直接继承自Person类，也就是说Student类直接继承了Person类中的属性，所以Student类的对象才可以访问到父类中的成员。
继承的特性
- 子类拥有父类非private的属性和方法；
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；
- 子类可以用自己的方式实现父类的方法；
- 在Java中只允许单继承，而不允许多重继承，也就是说一个子类只能有一个父类，但是Java中却允许多层继承，多层继承就是，例如类C继承类B，类B继承类A，所以按照关系就是类A是类B的父类，类B是类C的父类，这是Java继承区别于C++继承的一个特性；
- 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
多重继承：
class A{
...
}
class B{
...
}
class C extends A,B{
...
}
由上面可以发现类C同时继承了类A与类B，也就是说类C同时继承了两个父类，这在Java中是不允许的。多层继承：
class A{
...
}
class B extends A{
...
}
class C extends B{
...
}
由上面可以发现类B继承了类A，而类C又继承了类B，也就是说类B是类A的子类，而类C则是类A的孙子类。
子类对象的实例化过程
既然子类可以继承直接父类中的方法与属性，那父类中的构造方法呢？请看下面的范例：
public class TestPersonStudentDemo1 {
public static void main(String[] args) {
Student s = new Student();
}
}
class Person {
String name;
int age;
// 父类的构造方法
public Person() {
System.out.println("1.public Person(){}");
}
}
class Student extends Person {
String school;
// 子类的构造方法
public Student() {
System.out.println("2.public Student(){}");
}
}
输出结果：
1. public Person(){}
2. public Student(){}
从程序输出结果中可以发现，虽然程序第3行实例化的是子类的对象，但是程序却先去调用父类中的无参构造方法，之后再调用了子类本身的构造方法。所以由此可以得出结论，子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。
实际上在本范例中，在子类构造方法的第一行默认隐含了一个super()语句，上面的程序如果改写成下面的形式，也是可以的：
class Student extends Person{
String school ;
// 子类的构造方法
public Student(){
super() ; //实际上在程序的这里隐含了这样一条语句
System.out.println("2.public Student(){}");
}
}
继承条件下构造方法调用规则如下：
- 如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下写不写super()语句效果都是一样；
- 如果子类的构造方法中通过super显示调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法；
- 如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应构造方法中应用以上两条规则；
- 特别注意的是，如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。
编程要求
根据提示，在右侧编辑器Begin-End处补充代码：
- 声明一个Animal类，将属性name和age封装起来，提供对外的公共访问方法；
- 声明一个Cat类和Dog类，都继承Animal类，分别定义各自的voice方法和eat方法；
- 在main方法中分别实例化一个Cat对象和Dog对象，设置各自的属性并调用这两个方法，再打印出名字和年龄信息；
- 具体具体输出要求请看测试说明。
测试说明：
测试输入：无
预期输出：
大花猫喵喵叫
大花猫吃鱼
大花猫6岁
大黑狗汪汪叫
大黑狗吃骨头
大黑狗8岁
实现代码
package case2;
public class extendsTest {
public static void main(String args[]) {
// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
/********* begin *********/
Cat cat = new Cat();
cat.setName("大花猫");
cat.setAge(6);
cat.voice();
cat.eat();
System.out.println(cat.getName() + cat.getAge() + "岁");
/********* end *********/
// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
/********* begin *********/
Dog dog = new Dog();
dog.setName("大黑狗");
dog.setAge(8);
dog.voice();
dog.eat();
System.out.println(dog.getName() + dog.getAge() + "岁");
/********* end *********/
}
}
class Animal {
/********* begin *********/
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/********* end *********/
}
class Cat extends Animal {
// 定义Cat类的voice()和eat()方法
/********* begin *********/
public void voice() {
System.out.println(super.getName() + "喵喵叫");
}
public void eat() {
System.out.println(super.getName() + "吃鱼");
}
/********* end *********/
}
class Dog extends Animal {
// 定义Dog类的voice()和eat()方法
/********* begin *********/
public void voice() {
System.out.println(super.getName() + "汪汪叫");
}
public void eat() {
System.out.println(super.getName() + "吃骨头");
}
/********* end *********/
}
实验分析
2.错误代码：
Cat cat = new Cat();
cat.name = "大花猫"; //此处错误，name是私有变量，只能在Cat类中使用。
cat.age = 6;
第3关 super关键字的使用
任务描述
本关任务：掌握super关键字的使用。
相关知识
为了完成本关任务，你需要掌握：1.super关键字；2.super关键字的使用；3.super与this关键字的比较。
super关键字
在上一节中曾经提到过super的使用，那super到底是什么呢？super关键字出现在子类中，我们new子类的实例对象的时候，子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，所以可以得出结论：super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。
super关键字的使用
super关键字的用法如下：
- super可以用来引用直接父类的实例变量。
- super可以用来调用直接父类方法。
- super()可以用于调用直接父类构造函数。
1.super用于引用直接父类实例变量
public class TestSuper1 {
public static void main(String args[]) {
Dog d = new Dog();
d.printColor();
}
}
class Animal {
String color = "white";
}
class Dog extends Animal {
String color = "black";
void printColor() {
System.out.println(color);// prints color of Dog class
System.out.println(super.color);// prints color of Animal class
}
}
输出结果：
black
white
在上面的例子中，Animal和Dog都有一个共同的属性：color。 如果我们打印color属性，它将默认打印当前类的颜色。要访问父属性，需要使用super关键字指定。
2.通过super来调用父类方法
public class TestSuper2 {
public static void main(String args[]) {
Dog d = new Dog();
d.work();
}
}
class Animal {
void eat() {
System.out.println("eating...");
}
}
class Dog extends Animal {
void eat() {
System.out.println("eating bread...");
}
void bark() {
System.out.println("barking...");
}
void work() {
super.eat();
bark();
}
}
输出结果：
eating...
barking...
在上面的例子中，Animal和Dog两个类都有eat()方法，如果要调用Dog类中的eat()方法，它将默认调用Dog类的eat()方法，因为当前类的优先级比父类的高。所以要调用父类方法，需要使用super关键字指定。
3.使用super来调用父类构造函数
public class TestSuper3 {
public static void main(String args[]) {
Dog d = new Dog();
}
}
class Animal {
Animal() {
System.out.println("animal is created");
}
}
class Dog extends Animal {
Dog() {
super();
System.out.println("dog is created");
}
}
输出结果：
animal is created
dog is created
注意：如果没有使用super()或this()，则super()在每个类构造函数中由编译器自动添加。
super与this关键字的比较
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
范例：
public class TestAnimalDogDemo {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
输出结果：
animal : eat
dog : eat
animal : eat
上表对 this与 super 的差别进行了比较，从上表中不难发现，用 super或this 调用构造方法时都需要放在首行，所以super 与 this 调用构造方法的操作是不能同时出现的。
编程要求
comment: <> (“编程要求”部分介绍本关任务的具体要求，如实现步骤，规则等，最好能给出效果图)
根据提示，在右侧编辑器Begin-End处补充代码：
声明一个名为Person的类，里面有name与age两个属性，并声明一个含有两个参数的构造方法；
声明一个名为Student的类，此类继承自Person类，添加一个属性school，在子类的构造方法中调用父类中有两个参数的构造方法；
实例化一个Student类的对象``s，为Student对象s中的school赋值，打印输出姓名：
张三，年龄：18，学校：哈佛大学。
测试说明
测试输入：无
预期输出：
姓名：张三，年龄：18，学校：哈佛大学
实现代码：
package case3;
public class superTest {
public static void main(String[] args) {
// 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
/********* begin *********/
Student s = new Student();
//s.name = "张三"; //不为s.name和s.age赋值，父类构造方法中有两个参数，
//s.age = 18; //在子类构造方法调用父类构造方法时，name和age作为实参传递
s.school = "哈佛大学";
System.out.println("姓名："+s.name+"，年龄："+s.age+"，学校："+s.school);
/********* end *********/
}
}
class Person {
/********* begin *********/
String name;
int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
/********* end *********/
}
class Student extends Person {
/********* begin *********/
String school;
public Student(){ //子类构造方法。
super("张三",18); //调用父类构造方法，在此处传递姓名和年龄。
}
/********* end *********/
}
实验分析
- 子类中调用父类构造方法：
如果没有使用super()或this()，则super()在每个类构造函数中由编译器自动添加。 - 子类中调用父类普通方法：
Animal和Dog两个类都有eat()方法，如果要调用Dog类中的eat()方法，它将默认调用Dog类的eat()方法，因为当前类的优先级比父类的高。所以要调用父类方法，需要使用super关键字指定。 - name和age不直接赋值，而是以参数传值的方式传递给父类构造方法。
- 子类构造方法中，必须要调用父类构造方法
参考链接
参考链接
举例：
public Student(){ //子类构造方法。
super("张三",18); //调用父类构造方法，在此处传递姓名和年龄。
}
第4关：方法的重写与重载
本关任务：掌握方法的重写与重载。
相关知识
为了完成本关任务，你需要掌握：
1.方法的重写（override）；
2.方法的重载（overload）；
3.重写与重载之间的区别。
方法的重写（override）
- 方法的重写
子类从父类中继承方法，有时，子类需要修改父类中定义的方法的实现，这称做方法的重写(method overriding)。“重写”的概念与“重载”相似，它们均是Java“多态”的技术之一，所谓“重载”，即是方法名称相同，但却可在不同的场合做不同的事。当一个子类继承一父类，而子类中的方法与父类中的方法的名称、参数个数和类型都完全一致时，就称子类中的这个方法重写了父类中的方法。“重写”又称为“复写”、“覆盖”。 - 如何使用重写
class Super {
访问权限 方法返回值类型 方法1（参数1） {
...
}
}
class Sub extends Super{
访问权限 方法返回值类型 方法1（参数1） —————>复写父类中的方法
{
...
}
}
注意：方法重写时必须遵循两个原则，否则编译器会指出程序出错。
- 重写的方法不能比被重写的方法有更严格的访问权限;
- 重写的方法不能比被重写的方法产生更多的异常（关于异常，在后面会介绍）。
编译器加上这两个限定，是为了与Java语言的多态性（关于方法重写引起的运行时多态，在后面会详细讲述）特点一致而做出的。这样限定是出于对程序健壮性的考虑，为了避免程序执行过程中产生访问权限冲突或有应该捕获而未捕获的异常产生。
方法的重载（overload）
- 方法的重载
首先回顾一下前面所讲的方法的重载，方法重载是指多个方法可以享有相同的名字，但是参数的数量或类型不能完全相同。
调用方法时，编译器根据参数的个数和类型来决定当前所使用的方法。方法重载为程序的编写带来方便，是OOP多态性的具体变现。在Java系统的类库中，对许多重要的方法进行重载，为用户使用这些方法提供了方便。 - 重载的规则
- 被重载的方法必须改变参数列表(参数个数或类型不一样)；
- 被重载的方法可以改变返回类型；
- 被重载的方法可以改变访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
重写与重载之间的区别
方法的重写和重载是Java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
- 方法重载是一个类中定义了多个方法名相同，而他们的参数的数量不同或数量相同而类型和次序不同，则称为方法的重载；
- 方法重写是在子类存在方法与父类的方法的名字相同而且参数的个数与类型一样，返回值也一样的方法，就称为方法的重写；
- 方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。
编程要求
根据提示，在右侧编辑器补充代码。
- 声明一个名为Person的类，里面声明name与age两个属性，定义talk()方法返回姓名和年龄信息；
- 声明一个名为Student的类，此类继承自Person类，添加school属性，声明带三个参数的构造方法，复写talk()方法，在该方法中调用父类的talk()方法，返回姓名、年龄和学校信息；
- 实例化子类对象s，调用talk()方法打印我是：张三，今年：18岁，我在哈佛大学上学。
测试说明
测试输入： 无
预期输出：
我是：张三，今年：18岁，我在哈佛大学上学
实现代码
package case4;
public class overridingTest {
public static void main(String[] args) {
// 实例化子类对象s，调用talk()方法打印信息
/********* begin *********/
Student s = new Student("张三",18,"哈佛大学");
System.out.println(s.talk());
/********* end *********/
}
}
class Person {
/********* begin *********/
String name;
int age;
public String talk(){
return "我是："+this.name+"，今年："+this.age+"岁";
}
/********* end *********/
}
class Student extends Person {
/********* begin *********/
String school;
public Student(String name,int age,String school){
this.name = name;
this.age = age;
this.school = school;
}
public String talk(){
return super.talk()+"，我在"+this.school+"上学";
}
/********* end *********/
}
实验分析
- 构造方法相当于给属性赋值，本题中直接在子类构造方法中赋值。
- talk()方法同时返回姓名和年龄信息时，可以有这样的语句
return "我是："+this.name+"，今年："+this.age+"岁";
return super.talk()+"，我在"+this.school+"上学";