继承：将重复代码（共同的属性和方法）抽取到父类中，用于优化设计，单根继承，关键字：extends
子类重写父类方法时，权限需同级或更高，private < protected < public
参数类型和返回值都相同时才认为是方法重写
方法重写：父子，在子类中方法名保持一致，修饰符相同或等级更高，返回值一致或是父类方法中返回值对象的子类对象
在调用方法时，调用的是子类重写过的方法
声明父类，调用子类重写过的对象。（声明父类，new子类对象）
方法重载：在同一个类中，方法名相同，参数类型、数量、顺序不同
Object类是所有类的父类。
多态：一种行为多种状态，对于父类中的一个方法，不同的子类重写有不同的实现
★ 向上转型/向下转型：
面向对象的三大特征：封装、继承和多态，本实验任务需要大家掌握封装（private），先来掌握几个概念：
对象：用来描述客观事物的一个实体
属性：对象具有的各种特征
方法：对象执行的操作
类：具有相同属性和方法的一组对象的集合
类是对象的抽象，对象是类的具体
封装：用private关键字修饰属性，用private修饰的属性只能在当前类访问，如果外部类想要访问的话，只能通过set和get方法。
封装的好处：隐藏类的实现细节；让使用者只能通过程序员规定的方法（set、get）来访问数据，可以方便的加入存取控制语句，限制不合理操作。
继承（extends）是Java中实现代码重用的重要手段之一。继承就是 （1、 语义上有继承关系； 2、 纯粹为了代码共用）将相同的属性或者方法写到父类中 ,所有的子类共用
使用继承的好处：方便代码修改，减少代码量（直接在父类里面修改）Java中只支持单根继承，即一个类只能有一个直接父类
多态：一种行为，多种状态。即：声明父类，new子类对象，调用方法是子类重写过的方法，所以方法重写是多态的前提。
方法重写：在子类中根据需求对从父类继承的方法进行重新编写
向上转型：父类的引用指向子类对象。自动进行类型转换
向下转型：将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需强制类型转换
A类：
package com.liudm.demo7;
public class A {
public A(){
System.out.println("A");
}
static {
//静态代码块
System.out.println("static A");
}
}
B类继承A类：
package com.liudm.demo7;
public class B extends A{
public B(){
System.out.println("B");
}
static {
//静态代码块
System.out.println("static B");
}
}
C类继承B类：
package com.liudm.demo7;
public class C extends B{
A a = new A();
public C(){
B b = new B();
System.out.println("C");
}
static {
//静态代码块
System.out.println("static C");
}
public static void main(String[] args) {
C c = new C();
}
}
输出结果：
练习1、写一个Java应用程序，主要是体现父类子类间的继承关系。
父类：鸟；子类：麻雀、鸵鸟、鹰。子类继承父类的一些特点，如都是鸟的话就都会有翅膀、两条腿等属性，
但它们各自又有各自的特点，如麻雀的年龄、体重；鸵鸟的身高、奔跑速度；鹰的捕食、飞翔高度等。
编写测试类，调用子类中的方法
练习2、实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：
（1）Person类中的属性有：姓名name（String类型）、地址address（String类型）、电话号码telephone（String类型）和电子邮件地址email（String类型）。
（2）Employee类中的属性有：办公室office（String类型）、工资wage（double类型）和受雇日期hiredate（String类型）。
（3）Faculty类中的属性有：学位degree（String类型）、级别level（String类
型）。
（4）Staff类中的属性有：职务称号duty（String类型）
（5）编写测试类
Person类：
package com.liudm.demo7;
public class Person {
private String name;
private String address;
private double wage;
private String telenumber;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public double getWage() {
return wage;
}
public void setWage(double wage) {
this.wage = wage;
}
public String getTelenumber() {
return telenumber;
}
public void setTelenumber(String telenumber) {
this.telenumber = telenumber;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
Employee类：
package com.liudm.demo7;
public class Employee extends Person{
private String office;
private double wage;
private String hiredate;
public String getOffice() {
return office;
}
public void setOffice(String office) {
this.office = office;
}
public double getWage() {
return wage;
}
public void setWage(double wage) {
this.wage = wage;
}
public String getHiredate() {
return hiredate;
}
public void setHiredate(String hiredate) {
this.hiredate = hiredate;
}
}
Faculty类：
package com.liudm.demo7;
public class Faculty extends Employee{
String degree;
String level;
public String getDegree() {
return degree;
}
public void setDegree(String degree) {
this.degree = degree;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
}
Staff类：
package com.liudm.demo7;
public class Staff extends Employee{
String duty;
public String getDuty() {
return duty;
}
public void setDuty(String duty) {
this.duty = duty;
}
}
测试类：
package com.liudm.demo7;
public class Test2 {
public static void main(String[] args) {
Faculty f1 = new Faculty();
f1.setName("zhangsan");
f1.setTelenumber("123456");
f1.setOffice("beijing office");
f1.setWage(3000);
f1.setLevel("No.2");
f1.setDegree("本科");
System.out.println("姓名：" + f1.getName() + "\t电话：" + f1.getTelenumber() + "\t级别：" + f1.getLevel());
System.out.println("办公室：" + f1.getOffice() + "\t工资：" + f1.getWage() + "\t学位：" + f1.getDegree());
System.out.println();
Staff s1 = new Staff();
s1.setName("lisi");
s1.setAddress("longxiang street");
s1.setTelenumber("67890");
s1.setOffice("shanghai office");
s1.setWage(9000);
s1.setDuty("manager");
System.out.println("姓名：" + s1.getName() + "\t地址：" + s1.getAddress() + "\t电话：" + s1.getTelenumber());
System.out.println("办公室：" + s1.getOffice() + "\t工资：" + s1.getWage() + "\t职位：" + s1.getDuty());
}
}
练习3、在包com.bxk中编写一个类Father，具有属性：年龄（私有）、姓名（公有）；具有功能：工作（公有）、开车（公有）。
在包com.bxk中编写一个子类Son，具有属性：年龄（受保护的）、姓名；具有功能：玩（私有）、学习（公有）。
最后编写测试类Test，调用子类、父类属性和方法
练习4、编写一个Car类，具有final类型的属性品牌，具有功能drive；
定义其子类Aodi和Benchi，具有属性：价格、型号；具有功能：变速；定义主类E，
在其main方法中分别创建Aodi和Benchi的对象，并测试对象的特性。
练习5、按要求编写一个Java应用程序：
（1）定义一个类，描述一个矩形，包含有长、宽两种属性和计算面积方法。
（2）编写一个类，继承自矩形类，同时该类描述长方体，具有长、宽、高属性和计算体积的方法。
（3）编写一个测试类，对以上两个类进行测试，创建一个长方体，定义其长、宽、高，输出其底面积和体积。
矩形类：
package com.liudm.demo7;
public class Changfangxing {
private double chang;
private double kuan;
public double mianji(){
return this.chang*this.kuan;
}
public double getChang() {
return chang;
}
public void setChang(double chang) {
this.chang = chang;
}
public double getKuan() {
return kuan;
}
public void setKuan(double kuan) {
this.kuan = kuan;
}
}
长方体类：
package com.liudm.demo7;
public class Changfangti extends Changfangxing{
double gao;
public double tiji(){
return this.mianji()*this.gao;
}
public double getGao() {
return gao;
}
public void setGao(double gao) {
this.gao = gao;
}
}
测试类：
package com.liudm.demo7;
public class Test5 {
public static void main(String[] args) {
Changfangxing x = new Changfangxing();
Changfangti t = new Changfangti();
x.setChang(10);
x.setKuan(8);
System.out.println("长方形的面积是：" + x.mianji());
t.setChang(9);
t.setKuan(6);
t.setGao(5);
System.out.println("长方体的底面积是：" + t.mianji());
System.out.println("长方体的体积是：" + t.tiji());
}
}
练习6、编写一个类A，该类创建的对象可以调用方法f输出小写的英文字母表。
然后再编写一个A类的子类B，要求子类B必须继承A类的方法f（不允许重写），
子类B创建的对象不仅可以调用方法f输出小写的英文字母表，而且可以调用子类新增的方法g输出大写的英文字母表。
最后编写主类C，在主类的main方法中测试类A与类B。
练习7、编写一个Java应用程序，该程序包括3个类：Monkey、People类和主类E。要求：
（1）Monkey中有个构造方法：Monkey (String s)，并且有个public void speak()方法，在speak方法中输出“咿咿呀呀……”的信息。
（2）People是Monkey的子类，在People类中重写父类的方法speak(),在speak方法中输出“别说话！”的信息。
（3）在People类中新增方法void think()，在think方法中输出“认真思考！”。
（4）在主类E的main方法中创建Monkey与People的对象来测试这两个类的功能。
Monkey类：
package com.liudm.demo7;
public class Monkey {
String s;
public Monkey(String s){
super();
}
public void speak(){
System.out.println("咿咿呀呀...");
}
public String getS() {
return s;
}
public void setS(String s) {
this.s = s;
}
}
People类：
package com.liudm.demo7;
public class People extends Monkey{
public People(String s) {
super(s);
// TODO Auto-generated constructor stub
}
public void speak(){
System.out.println("别说话！");
}
public void think(){
System.out.println("认真思考！");
}
}
测试类：
package com.liudm.demo7;
public class Test7 {
public static void main(String[] args) {
Monkey m = new Monkey("一只猴");
m.speak();
People p = new People("一个人");
p.speak();
p.think();
}
}
练习8．编写一个Java应用程序，设计一个汽车类Vehicle，包含的属性有车轮个数wheels和车重weight。
小车类Car是Vehicle的子类，其中包含的属性有载人数loader。
卡车类Truck是Car类的子类，其中包含的属性有载重量payload。
每个类都有构造方法和输出相关数据的方法。最后，写一个测试类来测试这些类的功能。
练习9、编写一个Java应用程序，该程序包括3个类： A类、B类和主类E。其中类B是类A的子类，
在子类B中新增了成员变量和成员方法，并且隐藏了父类A的成员变量和重写了父类A的成员方法。
在主类E的main方法中，创建类B的对象并赋给父类A的对象a，使用上转型对象a来测试上转型对象的一些特性。