JAVA头歌实训 Java面向对象 - 封装、继承和多态的综合练习_头哥java面向对象 - 封装、继承和多态的综合练习

第1关：封装、继承和多态进阶（一）

任务描述
本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。

相关知识
为了完成本关任务，我们回顾一下前面所学知识：1.面向对象思想 ；2.封装；3.继承；4.构造函数；5.super()和this()。

面向对象思想
构造器：new就是一个构造器，作用是：①分配空间；②赋初始值（避免错误，简化输入）；

new Object(Parameters)构造器调用构造函数，传参为了赋初始值；

对象的基本元素是：属性和方法   类成员（属性和方法）。属性最为重要，属性的集合是一个状态，方法是一个状态到另一个状态的桥梁；

封装：属性和处理属性的方法集合起来。把数据及数据的操作方法放在一起，作为一个相互依存的整体，即对象。

面向对象是基于面向过程而言的，面向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第一位，而方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。

封装
访问权限的控制常被称为是具体实现的隐藏。把数据和方法包装进类中，以及具体实现的隐藏共同被称为封装。

public：可以被所有其他类访问；

protected：自身、子类、及同一个包中类（接受包外的子类访问）；

default：同一包中的类可以访问，声明时没有加修饰符，认为是friendly（拒绝一切外包访问）；

private：只能被自己访问和修改。

类的访问控制符只有三种：public、private、protected
default是无访问控制符。

继承
在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。继承使子类拥有父类所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。子类不能继承父类的构造函数，只是显式或隐式调用，可以从子类调用超类的构造函数。

 用new创建子类的对象时，若子类没有带参构造函数，将先执行父类的无参构造函数，然后再执行自己的构造函数。父类定义了有参的构造函数后，可以不定义无参的构造函数，系统也不会提供默认的无参构造函数。这时子类只能调用父类的有参构造函数。
Java类是单继承，Java接口可以多继承。类可以实现多个接口，接口可以继承（扩展）多个接口。先继承后实现接口。

组合和继承
组合是指在新类里面创建原有的类的对象，重复利用已有类的功能。（“has - a”）
组合和继承都允许在新的类中设置子对象，只是组合是显式的，而继承是隐式的。组合中的整体类和继承中的子类对应，组合中的局部类和继承中的父类对应。
组合和继承的选择规则：
① 除非两个类之间是“is - a”的关系，否则不要轻易地使用继承。过多的使用继承会破坏代码的可维护性，当父类修改时，会影响所有继承他的子类，增加了程序维护的难度和成本。
②不要仅仅为实现多态而使用继承，如果类之间没有“is - a”关系，可以通过实现接口与组合的方式来达到相同的目的。

构造函数
用来在对象实例化时初始化对象的成员变量。
特点：
① 方法名必须和类名相同，不能有返回值（也不能为void）；
② 一个类可以有多个构造函数，没有定义的话，编译器会在源代码编译成字节码文件的过程中会提供一个没有参数的默认的构造方法。若定义后，不会再创建默认的构造方法；
③构造函数的参数有（0到多个）；
④构造函数在对象实例化时会被自动调用，且只运行一次；普通方法是在程序执行到时才调用且可以被该对象调用多次；
⑤构造函数的作用是完成对象的初始化；
⑥构造函数不能被继承，不能被覆盖，能被重载；
⑦子类可以通过super()关键字来显示调用父类的构造函数，父类没有提供无参构造，子类的构造函数中必须显式得调用父类的构造函数；
⑧父类和子类都没有定义构造函数时，编译器都会为父类生成一个默认的无参构造，给子类也生成一个默认的无参的构造函数；
⑨构造方法会在成员变量之后初始化；
⑩构造方法不能被static、final、synchronize、abstract、native修饰，但可以被public、private、protect修饰。

在继承的时候，父类当然也有构造方法，如果你要创建子类的对象，那么执行的过程首先是调用父类的无参构造方法生成父类的对象，然后再调用子类的无参构造方法来生成子类对象。继承的时候都是先生成父类的对象，然后再生成子类的对象。

通过使用this关键字带上参数，可以在一个构造函数中调用另外一个构造函数。这是this除了单纯表示“当前对象”(注意是针对对象而不是类的概念)之外的第二个作用。但是注意3点:
① 必须放在第一行；

②只能调用一个其它的构造函数。(也许可以这样理解，正是因为有了第一点，如果可以调用多个的话，那么就无法放在“第一行”，所以只能允许一次调用)；

③只能是构造函数调用构造函数，普通函数无法调用构造函数。

super()和this()
super()关键字表示超类的意思，当前类是从超类继承而来。
this表示当前对象；

只有在重写(Override)父类的方法中，子类要调用继承自父类的方法，才使用super关键字。
使用super()或者this()方法是必须放在构造函数的第一行；

由于this函数指向的构造函数默认有super()方法，所以规定this()和super()不能同时出现在一个构造函数中。
因为static方法或者语句块没有实例时可以使用，而此时不需要构造实例，所以不能用this()和super()。

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

声明一个抽象类Pet，封装属性name和sex，声明一个带有两个参数的构造函数，声明抽象方法void talk()和void eat()；

声明一个Dog类继承自Pet，封装属性color，声明带有三个参数的构造函数，复写talk()和eat()方法；

声明一个Cat类继承自Pet，封装属性weight，声明带有三个参数的构造函数，复写talk()和eat()方法；

编写测试类，通过有参构造函数实例化Dog类对象，调用talk()方法和eat()方法；通过有参构造函数实例化Cat类对象 ，调用talk()方法和eat()方法；

具体输出要求请看测试说明。

测试说明
测试输入：
泰迪
male
brown
波斯猫
male
2.5
预期输出：
名称：泰迪，性别：male，颜色：brown，汪汪叫
泰迪吃骨头！
名称：波斯猫，性别：male，体重：2.5kg，喵喵叫
波斯猫吃鱼！

开始你的任务吧，祝你成功！

package case1;
 
import java.util.Scanner;
 
public class Task1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String dogName = sc.next();
		String dogSex = sc.next();
		String dogColor = sc.next();
		String catName = sc.next();
		String catSex = sc.next();
		double catWeight = sc.nextDouble();
		// 通过有参构造函数实例化Dog类对象dog
		// dog调用talk()方法
        // dog调用eat()方法
		/********* begin *********/
        Dog dog=new Dog(dogName,dogSex,dogColor);
        dog.talk();
        dog.eat();
		
		/********* end *********/
		// 通过有参构造函数实例化Cat类对象cat
		// cat调用talk()方法
		// cat调用eat()方法
		/********* begin *********/
Cat cat = new Cat(catName,catSex,catWeight);
        cat.talk();
        cat.eat();
		
		/********* end *********/
	}
}
 
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
	/********* begin *********/
private String name;
    private String sex;
    public Pet(String n,String s){
        this.name=n;
        this.sex=s;
    }
    public void output(){
        System.out.print("名称："+this.name+"，性别："+this.sex);
    }
    public void putName(){
        System.out.print(name);
    }
abstract public void talk();
    abstract public void eat();
 
	/********* end *********/
}
 
// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
	/********* begin *********/
private String color;
    public Dog(String n,String s,String c){
        super(n,s);
        this.color=c;
    }
    public void talk(){
        //System.out.println("名称："+this.name+"，性别："+this.sex+"，颜色："+this.color+"，汪汪叫");
        super.output();
        System.out.println("，颜色："+this.color+"，汪汪叫");
    }
    public void eat(){
        putName();
        System.out.println("吃骨头！");
    }
/********* end *********/
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
	/********* begin *********/
    private double weight;
    public Cat(String n,String s,double w){
        super(n,s);
        this.weight=w;
    }
public void talk(){
        //System.out.println("名称："+name+"，性别："+sex+"，体重："+weight+"kg，喵喵叫");
        output();
        System.out.println("，体重："+weight+"kg，喵喵叫");
    }
    public void eat(){
        putName();
        System.out.println("吃鱼！");
    }
	/********* end *********/
}

 第2关：封装、继承和多态进阶（二）

任务描述
本关任务：按要求编写一个Java应用程序，巩固Java封装、继承和多态的知识。

相关知识
为了完成本关任务，你需要掌握：1.重写和重载；2.abstract(抽象类)和interface(接口)；3.final关键字；4.static关键字；5.多态。

重写和重载
方法重载（overload）：

必须是同一个类；

方法名（也可以叫函数）一样；

参数类型不一样或参数数量或顺序不一样；

不能通过返回值来判断重载。

方法的重写（override）子类重写了父类的同名方法，两同两小一大原则：

方法名相同，参数类型相同；

子类返回类型是父类返回类型的子类；

子类抛出异常小于等于父类方法抛出异常；

子类访问权限大于等于父类方法访问权限。

在重写中，运用的是动态单分配，根据new的类型确定对象，从而确定调用的方法；

在重载中，运用的是静态多分配，根据静态类型确定对象，不能根据new的类型确定调用方法；

多态中，Father f = new Son()。

  成员变量：编译运行参考左边；
  成员函数：编译看左边，运行看右边；
  静态函数：编译运行看左边。

abstract(抽象类)和interface(接口)
抽象类

用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。

用abstract修饰的方法表示抽象方法，抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现，把具体实现留给继承该类的子类。

抽象类特点：

含有抽象方法的类必须声明为抽象类（不管其中是否有其他方法）；

抽象类可以没有抽象方法，可以有普通方法；

抽象类必须被继承，抽象方法必须被重写（若子类还是抽象类，不需要重写）；

抽象类不能被实例化（不能直接构造一个该类的对象）。

抽象方法特点：

在类中没有方法体（抽象方法只需声明，而不需实现某些功能）；

抽象类中的抽象方法必须被实现；

如果一个子类没有实现父类中的抽象方法，则子类也变成了一个抽象类。

接口
interface 中的方法默认为**public** abstract （public、abstract可以省略），变量默认为public static final；类中的方法全部都是抽象方法。只有声明没有实现，在不同类中有不同的方法实现。

不同点：

接口中只能包含抽象方法和默认方法，不能为普通方法提供方法实现；抽象类中可以包含普通方法；

接口里不能定义静态方法（jdk1.8下可以定义static方法），抽象类可以定义静态方法；

接口中只能定义静态常量，不能定义普通成员变量；抽象类即可以定义变量又可以定义静态常量；

接口中不包含构造器，抽象类里可以包含构造器，抽象类中的构造器并不是用于创建对象，而是让其他子类调用这些构造器来完成抽象类的初始化操作；

接口里不能包含初始化块，但抽象类可以包含；

一个类最多只能有一个父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。

共同点：

接口和抽象类都不能被实例化，都位于继承树的顶端，用于被其他类实现的继承；

接口和抽象类都可以包含抽象方法，实现接口和继承抽象类的普通子类都必须实现这些方法。

final关键字
final修饰的类，就是最终类，不能被继承。

final修饰的方法，就是最终方法，最终方法不能被重写。

final修饰一个引用变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。修饰基本数据类型变量时，内容不能变。

final成员变量必须在初始化代码块或在构造器中初始化。

作用：

final类：如果一个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计成final类。

final方法：①把方法锁定，防止任何继承类修改它的意义和实现。②高效，编译器在遇到调用final方法时候会转入内嵌机制，大大提升执行效率。

static关键字
static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效。**static不能修饰局部变量。static方法内部不能调用非静态方法。**

静态变量只能在类主体中定义，不能在方法中定义；

static变量只会创建一份，不管创建几个对象，都共用一个变量。

类方法指被static修饰的方法，无this指针。其他的就是实例方法。类方法可以调用其他类的static方法。
类方法和对象方法的区别：

1、 类方法是属于整个类的，而实例方法是属于类的某个对象的。
由于类方法是属于整个类的，并不属于类的哪个对象，所以类方法的方法体中不能有与类的对象有关的内容。即类方法体有如下限制：

类方法中不能引用对象变量；

类方法中不能调用类的对象方法；

在类方法中不能使用super、this关键字。（**this表示当前类的对象，由static修饰的方法是类直接调用，不需要创建对象，所以不能用this**）；

类方法不能被覆盖。

2、与类方法相比，对象方法几乎没有什么限制：

 对象方法中可以引用对象变量，也可以引用类变量；

对象方法中可以调用类方法；

对象方法中可以使用super、this关键字。

static关键字的作用

为某特定数据类型或对象分配单一的存储空间，而与创建对象的个数无关；实现某个方法或属性与类而不是对象关联在一起；

静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间。

多态
定义：不同类的对象对同一消息做出响应。同一消息可以根据发送对象的不同而采用多种不同的行为方式；

多态存在的三个必要条件：继承、重写、父类引用指向子类对象；

Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载；

父类引用指向子类对象，该引用不能再访问子类新增的成员。Animal cat = new Cat()与直接new一个父类实例(Animal a = new Animal())的区别？
答：当父类是接口和抽象类时，不能实例化，只能运用多态，向上转型。普通类中，可以在子类中重写父类中的方法，这样就可以访问子类中的重写方法。

编程要求
按照要求编写一个Java应用程序：

定义一个抽象类Person，包含抽象方法eat()，封装属性name、sex、age，声明包含三个参数的构造方法；

定义一个Chinese类，继承自Person类，重写父类的eat()方法，并定义一个自己特有的方法shadowBoxing()；

定义一个English类，继承自Person类，重写父类的eat()方法，并定义一个自己特有的方法horseRiding()；

编写测试类，定义一个showEat()方法，使用父类作为方法的形参，实现多态，分别调用showEat()方法，通过强制类型转换调用各自类特有的方法；

具体输出要求请看测试说明。

测试说明
测试输入：
张三
男
20
史蒂文
男
22
预期输出：
姓名：张三，性别：男，年龄：20，我是中国人，我喜欢吃饭!
姓名：史蒂文，性别：男，年龄：22，我是英国人，我喜欢吃三明治!
张三在练习太极拳!
史蒂文在练习骑马！

开始你的任务吧，祝你成功！

package case2;
 
import java.util.Scanner;
 
public class Task2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String cName = sc.next();
		String cSex = sc.next();
		int cAge = sc.nextInt();
		String eName = sc.next();
		String eSex = sc.next();
		int eAge = sc.nextInt();
        // 创建测试类对象test
		// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
		// 通过showEat()方法调用Chinese的eat()方法
		// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
		// 通过showEat()方法调用English的eat()方法
		/********* begin *********/
        Person person1=new Chinese(cName,cSex,cAge);
        showEat(person1);
        Person person2=new English(eName,eSex,eAge);
        showEat(person2);
       /********* end *********/
		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
		/********* begin *********/
        Chinese chi=(Chinese) person1;
        chi.shadowBoxing();
        English eng=(English) person2;
        eng.horseRiding();
 
		/********* end *********/
	}
// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
	/********* begin *********/
    public static void showEat(Person p){
        if (p instanceof Chinese) { 
            Chinese c = (Chinese) p;
            c.eat();
        } else if (p instanceof English) { 
            English c = (English) p;
            c.eat();
        }
    }
/********* end *********/
}
 
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
	/********* begin *********/
    //private String name;
    //private String sex;
    //private int age;
public String name;
    public String sex;
    public int age;
    abstract void eat();
    public Person(String n,String s,int age){
        this.name=n;
        this.sex=s;
        this.age=age;
    }
	/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
	/********* begin *********/
public Chinese(String n,String s,int age){
        super(n,s,age);
    }
    public void eat(){
        System.out.println("姓名："+this.name+"，性别："+this.sex+"，年龄："+this.age+"，我是中国人，我喜欢吃饭！");
    }
public void shadowBoxing(){
        System.out.println(name+"在练习太极拳！");
    }
 
	/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
	/********* begin *********/
public English (String n,String s,int age){
        super(n,s,age);
    }   
    void eat(){
        System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");
    }
public void horseRiding(){
        System.out.println(this.name+"在练习骑马！");
    }
 
	/********* end *********/
}

第3关：封装、继承和多态进阶（三）

任务描述

本关任务：通过一个简单实例讲解并自己动手编写一个Java应用程序，全面复习Java面向对象知识。

相关知识

为了完成本关任务，我们通过一个实例来一步一步总结归纳Java面向对象的知识。

1. package test;
2. /*知识点目录
3. 1，Java继承
4. 1.1 继承的概念
5. 1.2 继承的特性
6. 1.3 继承关键字
7. 1.4 构造器
9. 2，Java重写（Override）与重载（Overload）
10. 2.1 重写（Override）
11. 2.2 重载（Overload）
12. 2.3 总结
14. 3，Java多态
15. 3.1 多态的实现方式
17. 4，Java抽象类
19. 5，Java封装
21. 6，Java接口
23. */
24. /* 1.1继承的概念
25. 继承在本职上是特殊——一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法。通过 extends 关键字可以声明一个类是从另外一个类继承而来的。
26. */
28. /* 1.2继承的特性
29. 1).子类拥有父类非private的属性，方法；
30. 2).子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；
31. 3).子类可以用自己的方式实现父类的方法；
32. 4).Java的继承是单继承，这是Java继承区别于C++继承的一个特性；
33. 5).提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
34. */
36. /* 1.3继承关键字
37. 1).使用 extends 和 implements 来实现继承，所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承Object；
38. 2).一个子类只能拥有一个父类，所以 extends 只能继承一个类；
39. 3).使用 implements 关键字变相的使Java具有多继承的特性，为类继承接口，可以同时继承多个接口；
40. 4).通过super关键字来实现对父类成员的访问，用来引用当前对象的父类；
41. 5).final 关键字
42. 5.1) 声明类则把类定义为不能继承的，即最终类；修饰方法，则该方法不能被子类重写；定义实例变量，则变量不能被修改；
43. 5.2) final 类的方法自动为 final方法，但实例变量不自动是 final变量。
44. */
47. interface A{}
48. interface B{}
50. class Animal{
51. public void move(){
52. System.out.println("动物可以移动");
53. }
54. Animal(){
55. System.out.println("Animal()");
56. }
57. Animal(int n){
58. System.out.println("Animal(int)");
59. }
60. }
62. final class Dog extends Animal implements A,B {
64. final String name = "旺财";
65. final public void finalFun(){
67. }
69. /* 2.1.1 重写（Override）
70. 1).重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写；
71. 2).重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法；
72. 3).重写方法不能抛出新的检查异常或者比被重写方法声明更加宽泛的异常。
73. */
74. public void move(){
75. System.out.println("狗可以跳墙");
76. }
78. /*2.2.1重载(Overload)
79. 1).重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同；
80. 2).每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
81. */
82. public void move(int n){
83. System.out.println("这只狗可以跳"+n+"米的墙");
84. }
86. public String toString() {
87. //1.3.1 通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
88. return "I am a Dog " + super.toString();
89. }
91. /* 1.4 构造器
92. 1).子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表；
93. 2).如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。
94. */
95. Dog(){
96. super(300);
97. System.out.println("Dog()");
98. }
99. Dog(int n){
100. System.out.println("Dog(int)");
101. }
102. }
104. class Test{
105. static void testsuper(){
106. System.out.println("-----testsuper----");
107. new Dog();
108. new Dog(1);
109. }
110. static void testoverride(){
111. System.out.println("-----testoverride-----");
112. Animal a = new Animal();
113. Animal b = new Dog();
114. a.move();
116. /*2.1.2 重写（Override）
117. 1).尽管b属于Animal类型，但是它运行的是Dog类的move方法；
118. 2).在编译阶段，只是检查参数的引用类型。在运行时，Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。
119. */
120. b.move();
121. }
122. }
124. public class JavaDemo{
125. public static void main(String[] args) {
127. Test.testsuper();
128. Test.testoverride();
129. }
130. }
133. /* 2.1.3方法的重写规则
134. 1).参数列表必须完全与被重写方法的相同；
135. 2).返回类型必须完全与被重写方法的返回类型相同；
136. 3).访问权限不能比父类中被重写的方法的访问权限更低；
137. 4).父类的成员方法只能被它的子类重写；
138. 5).声明为final的方法不能被重写；
139. 6).声明为static的方法不能被重写，但是能够被再次声明；
140. 7).子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法；
141. 8).子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法；
142. 9).重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常，但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以；
143. 10).构造方法不能被重写；
144. 11).如果不能继承一个方法，则不能重写这个方法。
145. */
146. /*2.2.2重载规则
147. 1).被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
148. 2).被重载的方法可以改变返回类型；
149. 3).被重载的方法可以改变访问修饰符；
150. 4).被重载的方法可以声明新的或更广的检查异常；
151. 5).方法能够在同一个类中或者在一个子类中被重载；
152. 6).无法以返回值类型作为重载函数的区分标准。
153. */
154. /*
155. 重写与重载之间的区别
156. 区别点 重载方法 重写方法
157. 参数列表 必须修改 一定不能修改
158. 返回类型 可以修改 一定不能修改
159. 异常 可以修改 可以减少或删除，一定不能抛出新的或者更广的异常
160. 访问 可以修改 一定不能做更严格的限制（可以降低限制）
162. 总结
163. 方法的重写和重载是Java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载是一类中多态性的一种表现。
164. */
165. /*访问控制修饰符
166. Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
167. 默认的，也称为 default，在同一包内可见，不使用任何修饰符；
168. 私有的，以 private 修饰符指定，在同一类内可见；
169. 共有的，以 public 修饰符指定，对所有类可见；
170. 受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。
171. 我们可以可以通过以下表来说明访问权限：
172. 访问控制
173. 修饰符 当前类 同一包内 子孙类 其他包
174. public Y Y Y Y
175. protected Y Y Y N
176. default Y Y N N
177. private Y N N N
178. */
180. /*3，Java多态
181. 多态就是同一个接口，使用不同的实例执行不同操作。
182. 3.1 多态的实现方式 重写、接口、抽象类和抽象方法。
183. */
184. /*4，Java抽象类
185. 1).使用abstract class来定义抽象类，抽象类不能被实例化；
186. 2).抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类；
187. 3).抽象类中的抽象方法只是声明，不包含方法体；
188. 4).构造方法，类方法（用static修饰的方法）不能声明为抽象方法；
189. 5).任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
190. */
191. abstract class Employee{
192. //抽象方法
193. public abstract double computePay();
194. }
195. /*4.2继承抽象类
196. */
197. class Salary extends Employee{
198. public double computePay(){
199. return 0;
200. }
201. }
202. /*
203. 5，Java封装
204. 封装（英语：Encapsulation）是指，一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
205. 封装的优点：
207. 1).良好的封装能够减少耦合；
209. 2).类内部的结构可以自由修改；
211. 3). 可以对成员变量进行更精确的控制；
213. 4). 隐藏信息，实现细节。
215. 实现Java封装的步骤：
216. 1). 修改属性的可见性来限制对属性的访问；
217. 2).对每个值属性提供对外的公共方法访问。
218. */
220. /*
221. 6，Java接口
222. 1).接口，在Java编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明；
223. 2).一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类；
224. 3).接口不能包含成员变量，除了 static 和 final 变量；
225. 4).接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract；
226. 5).接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量；
227. 6).接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法；
228. 7).类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常；
229. 8).类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型；
230. 9).接口的继承使用extends关键字,允许多重继承,可能定义或继承相同的方法。
231. */
232. interface C extends A,B{}

输出结果： -----testsuper---- Animal(int) Dog() Animal() Dog(int) -----testoverride----- Animal() Animal(int) Dog() 动物可以移动 狗可以跳墙

编程要求

教练和运动员案例：

• 乒乓球运动员和篮球运动员；

• 乒乓球教练和篮球教练；

• 跟乒乓球相关的人员都需要学习英语；

• 分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

分析过程如下：

- 具体输出要求请看测试说明。

测试说明

测试输入： 张继科 30 易建联 31 刘国梁 42 杜锋 37 预期输出： 张继科---30 人都是要睡觉的 乒乓球运动员吃大白菜，喝小米粥 乒乓球运动员学习如何发球和接球 乒乓球运动员说英语 ---------------- 易建联---31 人都是要睡觉的 篮球运动员吃牛肉，喝牛奶 篮球运动员学习如何运球和投篮 ---------------- 刘国梁---42 人都是要睡觉的 乒乓球教练吃小白菜，喝大米粥 乒乓球教练教如何发球和接球 乒乓球教练说英语 ---------------- 杜锋---37 人都是要睡觉的 篮球教练吃羊肉，喝羊奶 篮球教练教如何运球和投篮 ----------------

---

开始你的任务吧，祝你成功！

package case3;
 
import java.util.Scanner;
 
public class Task3 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String pppName = sc.next();
		int pppAge = sc.nextInt();
		String bpName = sc.next();
		int bpAge = sc.nextInt();
		String ppcName = sc.next();
        int ppcAge = sc.nextInt();
		String bcName = sc.next();
		int bcAge = sc.nextInt();
		// 测试运动员(乒乓球运动员和篮球运动员)
		// 乒乓球运动员
		// 通过带参构造函数实例化PingPangPlayer对象ppp
		// 输出'name---age'
		// 分别调用sleep()、eat()、study()、speak()方法
		/********* begin *********/
        PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);
        //System.out.println(name+"---"+age);
        ppp.outInf();
        ppp.sleep();
        ppp.eat();
        ppp.study();
        ppp.speak();
 
		/********* end *********/
		System.out.println("----------------");
		// 篮球运动员
		// 通过带参构造函数实例化BasketballPlayer对象bp
// 输出'name---age'
		// 分别调用sleep()、eat()、study()方法
		/********* begin *********/
        BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);
        //System.out.println(name+"---"+age);
        bp.outInf();
        bp.sleep();
        bp.eat();
        bp.study();
/********* end *********/
		System.out.println("----------------");
		// 测试教练(乒乓球教练和篮球教练)
		// 乒乓球教练
		// 通过带参构造函数实例化PingPangCoach对象ppc
		// 输出'name---age'
		// 分别调用sleep()、eat()、teach()、speak()方法
		/********* begin *********/
        PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);
        //System.out.println(name+"---"+age);
ppc.outInf();
        ppc.sleep();
        ppc.eat();
        ppc.teach();
        ppc.speak();
 
		/********* end *********/
		System.out.println("----------------");
		// 篮球教练
		// 通过带参构造函数实例化BasketballCoach对象bc
		// 输出'name---age'
// 分别调用sleep()、eat()、teach()方法
		/********* begin *********/
        BasketballCoach bc=new BasketballCoach(bcName,bcAge);
        //System.out.println(name+"---"+age);
        bc.outInf();
        bc.sleep();
        bc.eat();
        bc.teach();
 
		/********* end *********/
		System.out.println("----------------");
	}
}
// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
	/********* begin *********/
    abstract void speak();
 
	/********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()（吃的不一样）
abstract class Person {
	/********* begin *********/
    String name;
    int age;
Person(){
        name =" ";
        age =0;
    }
    Person(String n,int a){
        this.name=n;
        this.age=a;
    }
    public void sleep(){
        System.out.println("人都是要睡觉的");
    }
public void outInf(){
        System.out.println(name+"---"+age);
    }
    abstract void eat();
 
	/********* end *********/
}
// 定义运动员Player（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
	/********* begin *********/
    Player(){
        super();
    }
Player(String n,int a){
        super(n,a);
    }
    abstract void study();
 
	/********* end *********/
}
// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
	/********* begin *********/
    Coach(){
        super();
    }
Coach(String n,int a){
        super(n,a);
    }
    abstract void teach();
 
	/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
	/********* begin *********/
    PingPangPlayer(){
        super();
    }
    PingPangPlayer(String n,int a){
        super(n,a);
    }
    public void eat(){
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }
public void study(){
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    public void speak(){
        System.out.println("乒乓球运动员说英语");
    }
 
	/********* end *********/
}
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
class BasketballPlayer extends Player {
	/********* begin *********/
    BasketballPlayer(){
        super();
    }
BasketballPlayer(String n,int a){
        super(n,a);
    }
    public void eat(){
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
public void study(){
        System.out.println("篮球运动员学习如何运球和投篮");
    }
 
	/********* end *********/
}
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
class PingPangCoach extends Coach implements SpeakEnglish {
	/********* begin *********/
    PingPangCoach(){
        super();
    }
PingPangCoach(String n,int a){
        super(n,a);
    }
    public void eat(){
System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }
    public void teach(){
        System.out.println("乒乓球教练教如何发球和接球");
    }
public void speak(){
        System.out.println("乒乓球教练说英语");
    }
 
	/********* end *********/
}
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach {
	/********* begin *********/
    BasketballCoach(){
        super();
    }
BasketballCoach(String n,int a){
        super(n,a);
    }
    public void eat(){
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
public void teach(){
        System.out.println("篮球教练教如何运球和投篮");
    }
	/********* end *********/
}