大家好，我是讯享网，很高兴认识大家。

目录

1. 第一关
   • 第一关答案
2. 第二关
   • 第二关答案
3. 第三关
   • 第三关答案
4. 第四关
   • 第四关答案

第一关 什么是封装，如何使用封装

封装时的权限控制符区别如下:

良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员进行更精确的控制。
隐藏信息，实现细节。
封装把一个对象的属性私有化，同时提供一些可以被外界访问属性的方法，如果不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。

public class Person { private String name; private int age; } 

讯享网

讯享网/* *封装演示 */ 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; } } 

采用this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

封装可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码，就可以对成员变量进行更精确的控制。

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; } 

编程要求
声明一个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.setName("张三"); p.setAge(18); // 调用Person类中的talk()方法 p.talk(); /* end */ } } // 在这里定义Person类 class Person { /* begin */ private String name; private int age; public String getNmae(){ return name; } public void setName(String name){ this.name = name; } public int getAge(){ return age; } public void setAge(int age){ this.age = age; } public void talk(){ System.out.println("我是："+name+"，今年："+age+"岁"); } /* end */ } 

目录

第二关 什么是继承，怎样使用继承

继承的基本概念
所谓继承：是指可以让某个类型的对象获得另一个类型的对象的属性的方法。

兔子和羊属于食草动物类，狮子和豹属于食肉动物类。

食草动物和食肉动物又是属于动物类。

所以继承需要符合的关系是：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类的无参构造方法为止。
编程要求
声明一个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.name = "大花猫"; cat.age = "6岁"; cat.voice(); cat.eat(); System.out.println(cat.name+cat.age); /* end */ // 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息 /* begin */ Dog dog = new Dog(); dog.name = "大黑狗"; dog.age = "8岁"; dog.voice(); dog.eat(); System.out.println(dog.name+dog.age); /* end */ } } class Animal { /* begin */ String name; String age; /* end */ } class Cat extends Animal { // 定义Cat类的voice()和eat()方法 /* begin */ public void voice(){ System.out.println(name+"喵喵叫"); } public void eat(){ System.out.println(name+"吃鱼"); } /* end */ } class Dog extends Animal { // 定义Dog类的voice()和eat()方法 /* begin */ public void voice(){ System.out.println(name+"汪汪叫"); } public void eat(){ System.out.println(name+"吃骨头"); } /* end */ } 

目录

第三关 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()在每个类构造函数中由编译器自动添加。

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 调用构造方法的操作是不能同时出现的。

编程要求
声明一个名为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.school = "哈佛大学"; System.out.println("姓名："+s.name+"，年龄："+s.age+"，学校："+s.school); /* end */ } } class Person { /* begin */ String name; int age; Person(){ } /* end */ } class Student extends Person { /* begin */ String name = "张三"; int age = 18; String school; Student(){ super(); } /* end */ } 

目录

第四关 方法的重写与重载

方法的重写（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 */ String name = "张三"; int age = 18; String scool = "哈佛大学"; Student s = new Student(name,age,scool); s.talk(); /* end */ } } class Person { /* begin */ String name; int age; public void talk(){ } /* end */ } class Student extends Person { /* begin */ String school; Student(String name,int age,String school){ this.name = name; this.age = age; this.school = school; } public void talk(){ super.talk(); System.out.println("我是："+name+"，今年："+age+"岁，我在"+school+"上学"); } /* end */ } 

目录

直接cv即可通过，但笔者建议理解后自己实践