Educoder/头歌JAVA——JAVA面向对象：封装、继承和多态

package case1;

public class TestPersonDemo {
	public static void main(String[] args) {
		/********* begin *********/
		// 声明并实例化一Person对象p
        Person p = new Person();
		// 给p中的属性赋值
        p.Set("张三",18);
		// 调用Person类中的talk()方法
        p.talk();

		/********* end *********/
	}
}
// 在这里定义Person类
class Person {
	/********* begin *********/
    private String name;
    private int age;
    public void talk(){
        System.out.println("我是："+this.name+"，今年："+this.age+"岁");
    }
    public void Set(String name,int age){
        this.name = name;
        this.age = age;
    }

	/********* end *********/
}

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

编程要求

根据提示，在右侧编辑器Begin-End处补充代码：

声明一个Animal类，将属性name和age封装起来，提供对外的公共访问方法；
声明一个Cat类和Dog类，都继承Animal类，分别定义各自的voice方法和eat方法；
在main方法中分别实例化一个Cat对象和Dog对象，设置各自的属性并调用这两个方法，再打印出名字和年龄信息；

package case2;

public class extendsTest {
	public static void main(String args[]) {
		// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
		/********* begin *********/
        Cat cat=new Cat();
        cat.Set("大花猫",6);
        cat.putName(); cat.voice();
        System.out.println();
        cat.putName();cat.eat();
        System.out.println();
        cat.putName();cat.putAge();
        System.out.println();

		/********* end *********/

// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
		/********* begin *********/
        Dog dog=new Dog();
        dog.Set("大黑狗",8);
        dog.putName(); dog.voice();
        System.out.println();
        dog.putName();dog.eat();
        System.out.println();
        dog.putName();dog.putAge();
        System.out.println();

		/********* end *********/
	}
}

class Animal {
	/********* begin *********/
    private String name;
    private int age;
    public void Set(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void putName(){
        System.out.print(this.name);
    }
    public void putAge(){
        System.out.print(this.age+"岁");
    }

	/********* end *********/

}

class Cat extends Animal {
	// 定义Cat类的voice()和eat()方法
	/********* begin *********/

    public void voice(){
        System.out.print("喵喵叫");
    }
    public void eat(){
        System.out.print("吃鱼");
    }

	/********* end *********/
}

class Dog extends Animal {
	// 定义Dog类的voice()和eat()方法
	/********* begin *********/
    public void voice(){
        System.out.print("汪汪叫");
    }
    public void eat(){
        System.out.print("吃骨头");
    }

	/********* end *********/
}

第3关：super关键字的使用

编程要求

根据提示，在右侧编辑器Begin-End处补充代码：

声明一个名为Person的类，里面有name与age两个属性，并声明一个含有两个参数的构造方法；
声明一个名为Student的类，此类继承自Person类，添加一个属性school，在子类的构造方法中调用父类中有两个参数的构造方法；
实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出姓名：张三，年龄：18，学校：哈佛大学。

package case3;

public class superTest {
	public static void main(String[] args) {
		// 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
		/********* begin *********/
        Student s=new Student("张三",18,"哈佛大学");        
        s.putout();

		/********* 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 *********/
    public String school;
    public Student(String name,int age,String school){
        super(name,age);
        this.school=school;
    }
    public void putout(){
        System.out.println("姓名："+this.name+"，年龄："+this.age+"，学校："+this.school);
    }

	/********* end *********/
}

第4关：方法的重写与重载

方法的重载（`overload`）

方法的重载

首先回顾一下前面所讲的方法的重载，方法重载是指多个方法可以享有相同的名字，但是参数的数量或类型不能完全相同。调用方法时，编译器根据参数的个数和类型来决定当前所使用的方法。方法重载为程序的编写带来方便，是OOP多态性的具体变现。在Java系统的类库中，对许多重要的方法进行重载，为用户使用这些方法提供了方便。
重载的规则
- 被重载的方法必须改变参数列表(参数个数或类型不一样)；
- 被重载的方法可以改变返回类型；
- 被重载的方法可以改变访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别

方法的重写和重载是Java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

方法重载是一个类中定义了多个方法名相同，而他们的参数的数量不同或数量相同而类型和次序不同，则称为方法的重载；
方法重写是在子类存在方法与父类的方法的名字相同而且参数的个数与类型一样，返回值也一样的方法，就称为方法的重写；
方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。

编程要求

根据提示，在右侧编辑器补充代码。

声明一个名为Person的类，里面声明name与age两个属性，定义talk()方法返回姓名和年龄信息；
声明一个名为Student的类，此类继承自Person类，添加school属性，声明带三个参数的构造方法，复写talk()方法，在该方法中调用父类的talk()方法，返回姓名、年龄和学校信息；

实例化子类对象s，调用talk()方法打印我是：张三，今年：18岁，我在哈佛大学上学。

package case4;

public class overridingTest {
	public static void main(String[] args) {
		// 实例化子类对象s，调用talk()方法打印信息
		/********* begin *********/
        Student s=new Student("张三",18,"哈佛大学");
        s.talk();

		/********* end *********/
		
	}
}

class Person {
	/********* begin *********/
    String name;
    int age;
    public void talk(){
        System.out.println("我是："+name+"，今年："+age+"岁");
    }

	/********* end *********/
}

class Student extends Person {
	/********* begin *********/
    String school;
    public Student(String n,int a,String sch){
        this.name=n;
        this.age=a;
        this.school=sch;
    }
    public void talk(){
        System.out.println("我是："+name+"，今年："+age+"岁，我在"+school+"上学");
    }

	/********* end *********/
}

第5关：抽象类

编程要求

根据提示，在右侧编辑器补充代码：

声明一个名为Person的抽象类，在Person类中声明了三个属性name、age和occupation和一个抽象方法talk()；
声明一个Student类和一个Worker类，都继承自Person类，添加带有三个参数的构造方法；

分别实例化Student类与Worker类的对象，分别调用各自类中被复写的talk()方法打印输出信息；

package case5;

public class abstractTest {
	public static void main(String[] args) {
		/********* begin *********/
		// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
		Student s=new Student("张三",20,"学生");
        Worker w=new Worker("李四",30,"工人");
		// 分别调用各自类中被复写的talk()方法 打印信息。
		s.talk();
        w.talk();
		/********* end *********/
		
	}
}

// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
	/********* begin *********/
    String name;
    int age;
    String occupation;
    abstract public void talk();

	/********* end *********/
}

// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
	/********* begin *********/
    public Student(String n,int a,String o){
        this.name=n;
        this.age=a;
        this.occupation=o;
    }
    public void talk(){
        System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
    }

	/********* end *********/
}

// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
	/********* begin *********/
    public Worker(String n,int a,String o){
        this.name=n;
        this.age=a;
        this.occupation=o;
    }
    public void talk(){
        System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
    }

	/********* end *********/
}

第6关：final关键字的理解与使用

`final`关键字修饰类、成员变量和成员方法

1.`final`类

final用来修饰一个类，意味着该类成为不能被继承的最终类。出于安全性的原因和效率上的考虑，有时候需要防止一个类被继承。例如，Java类库中的String类，它对编译器和解释器的正常运行有着很重要的作用，不能轻易改变它，因此把它修饰为final类，使它不能被继承，这就保证了String类的惟一性。同时，如果你认为一个类的定义己经很完美，不需要再生成它的子类，这时也应把它修饰为final类。定义一个final类的格式如下:

final class ClassName{
...
}

注意：声明为final的类隐含地声明了该类的所有方法为final方法。

下面的结论是成立的：声明一个类既为abstract，又为final是非法的，因为抽象类必须被子类继承来实现它的抽象方法。下面是一个final类的例子:

final class A{
...
}
class B extends A{//错误！不能继承A
...
}

2.`final`修饰成员变量

变量被声明为final后，成为常值变量(即常量)，一旦被通过某种方式初始化或赋值，即不能再被修改。通常 static与final一起 使用来指定一个类常量。例如:

static final int SUNDAY=0;

把final变量用大写字母和下划线来表示，这是一种编码规定。

3.`final`修饰成员方法

用final修饰的方法为最终方法，不能再被子类重写，可以被重载。尽管方法重写是Java非常有力的特征，但有时却需要避免这种情况的发生。为了不允许一个方法被重写，在方法的声明中指定final属性即可。例如:

class A{
final void method(){}
}
class B extends A{//定义A类的一个子类B
void method(){}//错误，method()不能被重写
}

该例中，因为method()方法在A中被声明为final，所以不能在子类B中被重写。如果这样做，将导致编译错误。方法被声明为final有时可以提高性能：编译器可以自由地内联调用它们，因为它“知道”它们不会被子类重写。

编程要求

根据提示，在右侧编辑器Begin-End处补充代码:

仔细阅读代码，在右侧编辑器中调整代码使程序能正确编译运行;

package case6;

public class finalTest {
	public static void main(String args[]) {
		Bike1 obj = new Bike1();
		obj.run();

		Honda honda = new Honda();
		honda.run();

		Yamaha yamaha = new Yamaha();
		yamaha.run();
	}
}
//不可以修改 final 变量的值
// final方法,不可以重写
// 不可以扩展 final 类
    //请在此添加你的代码
    /********** Begin *********/

	class Bike1 {
	int speedlimit = 90;

	void run() {
		speedlimit = 120; 
		System.out.println("speedlimit=120");
	}
}

class Bike2 {
	void run() {
		System.out.println("running");
	}
}

class Honda extends Bike2 {
	void run() { 
		System.out.println("running safely with 100kmph");
	}
}

final class Bike3 {
}

class Yamaha  { 
	void run() {
		System.out.println("running safely with 100kmph");
	}

}
    /********** End **********/

第7关：接口

编程要求

根据提示，在右侧编辑器补充代码：

声明一Person接口，并在里面声明三个常量：name、age、occupation，并分别赋值；
声明一Student类，此类实现Person接口，并复写Person中的talk()方法；
实例化一Student的对象s，并调用talk()方法，打印信息；

package case7;

public class interfaceTest {
	public static void main(String[] args) {
		// 实例化一Student的对象s，并调用talk()方法，打印信息
		/********* begin *********/
        Student s=new Student();
        s.talk();

		/********* end *********/

	}
}

// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
interface Person {
	/********* begin *********/
    final String name="张三";
    final int age=18;
    final String occupation="学生";
    abstract public void talk();

	/********* end *********/
}

// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
	/********* begin *********/
    public void talk(){
        System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
    }

	/********* end *********/
}

第8关：什么是多态，怎么使用多态

多态的实现条件

多态的三个条件:

继承的存在(继承是多态的基础，没有继承就没有多态)；
子类重写父类的方法(多态下调用子类重写的方法)；
父类引用变量指向子类对象(子类到父类的类型转换)。

子类转换成父类时的规则:

将一个父类的引用指向一个子类的对象，称为向上转型(upcasting)，自动进行类型转换。此时通过父类引用调用的方法是子类覆盖或继承父类的方法，不是父类的方法。此时通过父类引用变量无法调用子类特有的方法；
如果父类要调用子类的特有方法就得将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转型，此时必须进行强制类型转换。

以下是一个多态实例的演示，详细说明请看注释：

public class TestAnimalDemo {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat) a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat) a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog) a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}

输出结果： 吃鱼 抓老鼠 吃骨头 看家 吃鱼 抓老鼠

可以用 instanceof 判断一个类是否实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。instanceof 的语法格式为:

对象 instanceof 类(或接口)

它的返回值是布尔型的，或真(true)、或假(false)。 #####多态的实现形式在Java中有两种形式可以实现多态：继承和接口。

基于继承实现的多态

基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。

如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

基于接口实现的多态

继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可能是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

在接口的多态中，指向接口的引用必须是指定实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

编程要求

根据提示，在右侧编辑器补充代码：

声明一个Animal类，此类中定义eat()方法；
声明Dog类、Cat类、Lion类，均继承自Animal类，并复写了eat()方法；
运用多态方式实例化子类对象并调用eat()方法打印输出信息；

package case8;

public class TestPolymorphism {
	public static void main(String[] args) {
		// 以多态方式分别实例化子类对象并调用eat()方法
		/********* begin *********/
        Dog dog=new Dog();
        Cat cat=new Cat();
        Lion lion=new Lion();
        dog.eat();
        cat.eat();
        lion.eat();

		/********* end *********/
	}
}
// Animal类中定义eat()方法
class Animal {
	/********* begin *********/
    public void eat(){
        System.out.print("...");

    }

	/********* end *********/
}
// Dog类继承Animal类 复写eat()方法
class Dog extends Animal {
	/********* begin *********/
    public void eat(){
        System.out.println("eating bread...");
    }

	/********* end *********/
}
// Cat类继承Animal类 复写eat()方法
class Cat extends Animal {
	/********* begin *********/
    public void eat(){
        System.out.println("eating rat...");
    }

	/********* end *********/
}
// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
	/********* begin *********/
    public void eat(){
        System.out.println("eating meat...");
    }

	/********* end *********/
}