1.1、 概述：
由来：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：
其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。继承描述的是事物之间的所属关系，这种关系是：is-a （就是继承关系）的关系。例如，图中鹿属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。
定义：继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
优点： 提高代码的复用性。类与类之间产生了关系，是多态的前提。1.2、继承的格式：
继承演示，代码如下：
定义员工类Employee，做为父类：
// 定义一个父类：员工 public class Employee { public void method() { System.out.println("方法执行！"); } }定义讲师类Teacher继承员工类Employee:
// 定义了一个员工的子类：讲师 public class Teacher extends Employee { }定义测试类:
/* 在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。 例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。 定义父类的格式：（一个普通的类定义） public class 父类名称 { // ... } 定义子类的格式： public class 子类名称 extends 父类名称 { // ... } */ public class DemoExtends { public static void main(String[] args) { // 创建了一个子类对象 Teacher teacher = new Teacher(); // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。 teacher.method(); } }1.3、继承后的特点 – 成员变量：
当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？
成员变量不重名： 如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：父类：
public class Fu { int numFu = 10; int num = 100; public void methodFu() { // 使用的是本类当中的，不会向下找子类的 System.out.println(num); } }子类：
public class Zi extends Fu { int numZi = 20; int num = 200; public void methodZi() { // 因为本类当中有num，所以这里用的是本类的num System.out.println(num); } }测试类：
public class Demo01ExtendsField { public static void main(String[] args) { Fu fu = new Fu(); // 创建父类对象 System.out.println(fu.numFu); //10 只能使用父类的东西，没有任何子类内容 System.out.println("==========="); Zi zi = new Zi(); System.out.println(zi.numFu); // 10 System.out.println(zi.numZi); // 20 System.out.println("==========="); // 等号左边是谁，就优先用谁 System.out.println(zi.num); // 优先子类，200 //System.out.println(zi.abc); // 到处都没有，编译报错！ System.out.println("==========="); // 这个方法是子类的，优先用子类的，没有再向上找 zi.methodZi(); // 200 // 这个方法是在父类当中定义的， zi.methodFu(); // 100 } }注意： 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
直接 通过子类对象访问成员变量： 等号左边是谁，就优先用谁，没有则向上找。间接 通过成员方法访问成员变量： 该方法属于谁，就优先用谁，没有则向上找。父类：
public class Fu { int num = 10; }子类：
public class Zi extends Fu { int num = 20; public void method() { int num = 30; System.out.println(num); // 30，局部变量 System.out.println(this.num); // 20，本类的成员变量 System.out.println(super.num); // 10，父类的成员变量 } }测试类：
public class DemoExtendsField { public static void main(String[] args) { Zi zi = new Zi(); zi.method(); } }小贴士：
局部变量： 直接写成员变量名本类的成员变量： this.成员变量名父类的成员变量： super.成员变量名父类中的成员变量是非私有的，子类中可以直接访问。若父类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。1.4、继承后的特点 – 成员方法：
当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？
成员方法不重名：如果子类父类中出现 不重名 的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，==若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。==代码如下：
父类：
public class Fu { public void methodFu() { System.out.println("父类方法执行！"); } public void method() { System.out.println("父类重名方法执行！"); } }子类：
public class Zi extends Fu { public void methodZi() { System.out.println("子类方法执行！"); } public void method() { System.out.println("子类重名方法执行！"); } }测试类：
/* 在父子类的继承关系当中，创建子类对象，访问成员方法的规则： 创建的对象是谁，就优先用谁，如果没有则向上找。 */ public class Demo01ExtendsMethod { public static void main(String[] args) { Zi zi = new Zi(); zi.methodFu(); zi.methodZi(); // 创建的是new了子类对象，所以优先用子类方法 zi.method(); } }注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
重写（Override） 概念：在继承关系当中，方法的名称一样，参数列表也一样。
重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
1.5、成员方法重名——重写(Override)：
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做 方法重写(Override)。
方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
演示代码如下：
重写的应用： 子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能，代码如下：
老版手机类：
public class Phone { public void call() { System.out.println("打电话"); } public void send() { System.out.println("发短信"); } public void show() { System.out.println("显示号码"); } }新版手机类：
// 定义一个新手机，使用老手机作为父类 public class NewPhone extends Phone { @Override public void show() { super.show(); // 把父类的show方法拿过来重复利用 // 自己子类再来添加更多内容 System.out.println("显示姓名"); System.out.println("显示头像"); } }测试类：
public class Demo01Phone { public static void main(String[] args) { Phone phone = new Phone(); phone.call(); phone.send(); phone.show(); System.out.println("=========="); NewPhone newPhone = new NewPhone(); newPhone.call(); newPhone.send(); newPhone.show(); } }小贴士： 这里重写时，用到super.父类成员方法，表示调用父类的成员方法。
注意事项：
必须保证父子类之间方法的名称相同，参数列表也相同。@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
子类方法的返回值必须【小于等于】父类方法的返回值范围。小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
子类方法的权限必须【大于等于】父类方法的权限修饰符。小扩展提示：public > protected > (default) > private 备注：(default)不是关键字default，而是什么都不写，留空。
1.6、继承后的构造方法——构造方法：
当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？
首先我们要回忆两个事情，构造方法的定义格式和作用。
构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。构造方法的作用是初始化成员变量的。所以**子类的初始化过程中，必须先执行父类的初始化动作**。子类的构造方法中默认有一个super()，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代码如下：父类：
public class Fu { public Fu() { System.out.println("父类无参构造"); } public Fu(int num) { System.out.println("父类有参构造！"); } }子类：
public class Zi extends Fu { public Zi() { super(); // 在调用父类无参构造方法 ，自动增送 ，可以不写 //super(20); // 在调用父类重载的构造方法 System.out.println("子类构造方法！"); } public void method() { // super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。 } }测试类：
public class Demo01Constructor { public static void main(String[] args) { Zi zi = new Zi(); } }继承关系中，父子类构造方法的访问特点：
子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。子类构造可以通过super关键字来调用父类重载构造。super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。总结：子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。1.7、super 和 this：
父类空间优先于子类对象产生：
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。理解图解如下：
super和this的含义super：
super 代表父类的存储空间标识(可以理解为父亲的引用)。this：代表当前对象的引用(谁调用就代表谁)。
super 和 this的用法：
1. 访问成员： 用法演示，代码如下：
2. 访问构造方法：
子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。super()和this()都必须是在构造方法的第一行，所以不能同时出现
3. 子类和父类是一种相对的概念。
2.1、概述：
由来： 父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
定义： 抽象方法：没有方法体的方法。 抽象类：包含抽象方法的类。
2.2、abstract使用格式：
抽象方法：使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
抽象类：如果一个类包含抽象方法，那么该类必须是抽象类。
定义格式:
abstract class 类名 { }代码举例：
public abstract class Animal { public abstract void run(); }2.4、抽象的使用：
继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。
代码举例：
此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。
2.5、注意事项：（重点,理解为主）
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
群主发红包:
群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：
群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。成员领取红包后，保存到成员余额中。请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。案例分析：
案例实现：
定义一个用户类：
public class User { private String name; private double money; public User() { } public User(String name, double money) { this.name = name; this.money = money; } public void show() { System.out.println("用户为：" +this.name+" 账户上有 "+this.money+" 块钱"); } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } }定义一个群主类：
package com.xxw.advancecodes; import java.math.BigDecimal; import java.util.ArrayList; public class haremMaster extends User{ public haremMaster() { } public haremMaster(String name, double money) { super(name, money); } public ArrayList<Double> givePacket(int totalMoney,int sum){ ArrayList<Double> redList = new ArrayList<>(); double money = super.getMoney(); // 获取群主当前余额多少 if(money < totalMoney){ System.out.println("老板你钱不够呀，别装大款啦，有多少就发多少。"); return redList ; } super.setMoney(money-totalMoney); // 重置一下群主的金额 double averMoney = new BigDecimal((double)totalMoney/sum). setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue(); // 保留两位小数 for (int i = 0; i < sum; i++) { redList.add(averMoney); } return redList; } }定义一个群员类：
package com.xxw.advancecodes; import java.util.ArrayList; import java.util.Random; public class Member extends User{ public Member() { } public Member(String name, double money) { super(name, money); } public void receivePacket(ArrayList<Double> list){ if (list.size()>0){ // 判断集合是否为空 , 为空不执行 // 随机抽取一个红包 int index = new Random().nextInt(list.size()); // 获取这个成员本来有多少钱 double money = super.getMoney(); // 把红包的钱存入个人账户 super.setMoney(list.get(index)+money); // 删除集合中被选中的这个红包,防止下一次又选到这个红包了 list.remove(index); } } }测试类：
// 发红包 ， 普通红包案例 package com.xxw.advancecodes; import java.util.ArrayList; import java.util.Scanner; public class redPacket { public static void main(String[] args) { haremMaster master = new haremMaster("老大",100); Member member01 = new Member("小弟一号",0); Member member02 = new Member("小弟二号",2.5); Member member03 = new Member("小弟三号",10); Member member04 = new Member("小弟四号",250); // 打印一下初始值 master.show(); member01.show(); member02.show(); member03.show(); member04.show(); System.out.println("================================="); System.out.print("群主你想发几块钱的红包呢？"); int inputMoney = new Scanner(System.in).nextInt(); // 输入发红包的金额 System.out.println("=============恭喜发财=============="); ArrayList<Member> members = new ArrayList<>(); // 把成员放到一个集合 // 添加成员 members.add(member01); members.add(member02); members.add(member03); members.add(member04); ArrayList<Double> redList = master.givePacket(inputMoney,members.size()); for (int i = 0; i < members.size(); i++) { members.get(i).receivePacket(redList); // 成员抢红包 } // 抢红包后各自的余额显示 master.show(); member01.show(); member02.show(); member03.show(); member04.show(); System.out.println("=============抢红包结束============="); } }效果展示：
测试一：
测试二：
鼠标左击以确定代码插入的位置，使用快捷键Ctrl+O，会弹出窗口让选择某个方法，例如：
双击要override的方法即可以快速重写父类。
