第1节 继承

day09_01_继承的概述

day09_02_继承的格式

day09_03_继承中成员变量的访问特点

day09_04_区分子类方法中重名的三种变量

day09_05_继承中成员方法的访问特点

day09_06_继承中方法的覆盖重写_概念与特点

day09_07_继承中方法的覆盖重写_注意事项

day09_08_继承中方法的覆盖重写_应用场景

day09_09_继承中构造方法的访问特点

day09_10_super关键字的三种用法

day09_11_this关键字的三种用法

day09_12_super与this关键字图解

day09_13_Java继承的三个特点

课后练习

第2节 抽象类

day09_14_抽象的概念

day09_15_抽象方法和抽象类的格式

day09_16_抽象方法和抽象类的使用

day09_17_抽象方法和抽象类的注意事项

day09_18_发红包案例_分析

day09_19_发红包案例_实现

课后练习

1 package cn.itcast.day09.demo01;
2
3 /*
4 在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
5 例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。
6
7 定义父类的格式：（一个普通的类定义）
8 public class 父类名称 {
9 // …
10 }
11
12 定义子类的格式：
13 public class 子类名称 extends 父类名称 {
14 // …
15 }
16 */
17 public class Demo01Extends {
18
19 public static void main(String[] args) {
20 // 创建了一个子类对象
21 Teacher teacher = new Teacher();
22 // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
23 teacher.method();
24
25 // 创建另一个子类助教的对象
26 Assistant assistant = new Assistant();
27 assistant.method();
28 }
29
30 }

1 package cn.itcast.day09.demo01;
2
3 // 定义一个父类：员工
4 public class Employee {
5
6 public void method() {
7 System.out.println("方法执行！");
8 }
9
10 }

1 package cn.itcast.day09.demo01;
2
3 // 定义了一个员工的子类：讲师
4 public class Teacher extends Employee {
5 }

1 package cn.itcast.day09.demo01;
2
3 // 定义了员工的另一个子类：助教
4 public class Assistant extends Employee {
5 }

1 package cn.itcast.day09.demo02;
2
3 /*
4 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
5
6 直接通过子类对象访问成员变量：
7 等号左边是谁，就优先用谁，没有则向上找。
8 间接通过成员方法访问成员变量：
9 该方法属于谁，就优先用谁，没有则向上找。
10 */
11 public class Demo01ExtendsField {
12
13 public static void main(String[] args) {
14 Fu fu = new Fu(); // 创建父类对象
15 System.out.println(fu.numFu); // 只能使用父类的东西，没有任何子类内容
16 System.out.println("===========");
17
18 Zi zi = new Zi();
19
20 System.out.println(zi.numFu); // 10
21 System.out.println(zi.numZi); // 20
22 System.out.println("===========");
23
24 // 等号左边是谁，就优先用谁
25 System.out.println(zi.num); // 优先子类，200
26 // System.out.println(zi.abc); // 到处都没有，编译报错！
27 System.out.println("===========");
28
29 // 这个方法是子类的，优先用子类的，没有再向上找
30 zi.methodZi(); // 200
31 // 这个方法是在父类当中定义的，
32 zi.methodFu(); // 100
33 }
34
35 }

1 package cn.itcast.day09.demo02;
2
3 public class Fu {
4
5 int numFu = 10;
6
7 int num = 100;
8
9 public void methodFu() {
10 // 使用的是本类当中的，不会向下找子类的
11 System.out.println(num);
12 }
13
14 }

package cn.itcast.day09.demo02;

public class Zi extends Fu {

int numZi = 20;

int num = 200;

public void methodZi() {  
    // 因为本类当中有num，所以这里用的是本类的num  
    System.out.println(num);  
}

}

1 package cn.itcast.day09.demo03;
2
3 /*
4 局部变量： 直接写成员变量名
5 本类的成员变量： this.成员变量名
6 父类的成员变量： super.成员变量名
7 */
8 public class Demo01ExtendsField {
9
10 public static void main(String[] args) {
11 Zi zi = new Zi();
12
13 zi.method();
14 }
15
16 }

1 package cn.itcast.day09.demo03;
2
3 public class Fu {
4
5 int num = 10;
6
7 }

1 package cn.itcast.day09.demo03;
2
3 public class Zi extends Fu {
4
5 int num = 20;
6
7 public void method() {
8 int num = 30;
9 System.out.println(num); // 30，局部变量
10 System.out.println(this.num); // 20，本类的成员变量
11 System.out.println(super.num); // 10，父类的成员变量
12 }
13
14 }

1 package cn.itcast.day09.demo04;
2
3 /*
4 在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
5 创建的对象是谁，就优先用谁，如果没有则向上找。
6
7 注意事项：
8 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
9
10 重写（Override）
11 概念：在继承关系当中，方法的名称一样，参数列表也一样。
12
13 重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
14 重载（Overload）：方法的名称一样，参数列表【不一样】。
15
16 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
17 */
18 public class Demo01ExtendsMethod {
19
20 public static void main(String[] args) {
21 Zi zi = new Zi();
22
23 zi.methodFu();
24 zi.methodZi();
25
26 // 创建的是new了子类对象，所以优先用子类方法
27 zi.method();
28 }
29
30 }

1 package cn.itcast.day09.demo04;
2
3 public class Fu {
4
5 public void methodFu() {
6 System.out.println("父类方法执行！");
7 }
8
9 public void method() {
10 System.out.println("父类重名方法执行！");
11 }
12
13 }

1 package cn.itcast.day09.demo04;
2
3 public class Zi extends Fu {
4
5 public void methodZi() {
6 System.out.println("子类方法执行！");
7 }
8
9 public void method() {
10 System.out.println("子类重名方法执行！");
11 }
12
13 }

1 package cn.itcast.day09.demo05;
2
3 /*
4 方法覆盖重写的注意事项：
5
6 1. 必须保证父子类之间方法的名称相同，参数列表也相同。
7 @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
8 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
9
10 2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
11 小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
12
13 3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
14 小扩展提示：public > protected > (default) > private
15 备注：(default)不是关键字default，而是什么都不写，留空。
16 */
17 public class Demo01Override {
18
19 }

1 package cn.itcast.day09.demo05;
2
3 public class Fu {
4
5 public String method() {
6 return null;
7 }
8
9 }

1 package cn.itcast.day09.demo05;
2
3 public class Zi extends Fu {
4
5 @Override
6 public String method() {
7 return null;
8 }
9
10 }

1 package cn.itcast.day09.demo06;
2
3 public class Demo01Phone {
4
5 public static void main(String[] args) {
6 Phone phone = new Phone();
7 phone.call();
8 phone.send();
9 phone.show();
10 System.out.println("==========");
11
12 NewPhone newPhone = new NewPhone();
13 newPhone.call();
14 newPhone.send();
15 newPhone.show();
16 }
17
18 }

1 package cn.itcast.day09.demo06;
2
3 // 定义一个新手机，使用老手机作为父类
4 public class NewPhone extends Phone {
5
6 @Override
7 public void show() {
8 super.show(); // 把父类的show方法拿过来重复利用
9 // 自己子类再来添加更多内容
10 System.out.println("显示姓名");
11 System.out.println("显示头像");
12 }
13 }

1 package cn.itcast.day09.demo06;
2
3 // 本来的老款手机
4 public class Phone {
5
6 public void call() {
7 System.out.println("打电话");
8 }
9
10 public void send() {
11 System.out.println("发短信");
12 }
13
14 public void show() {
15 System.out.println("显示号码");
16 }
17
18 }

1 package cn.itcast.day09.demo07;
2
3 /*
4 继承关系中，父子类构造方法的访问特点：
5
6 1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
7 2. 子类构造可以通过super关键字来调用父类重载构造。
8 3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
9 总结：
10 子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
11 */
12 public class Demo01Constructor {
13
14 public static void main(String[] args) {
15 Zi zi = new Zi();
16 }
17
18 }

1 package cn.itcast.day09.demo07;
2
3 public class Fu {
4
5 public Fu() {
6 System.out.println("父类无参构造");
7 }
8
9 public Fu(int num) {
10 System.out.println("父类有参构造！");
11 }
12
13 }

package cn.itcast.day09.demo07;

public class Zi extends Fu {

public Zi() {  
    super(); // 在调用父类无参构造方法  

// super(20); // 在调用父类重载的构造方法
System.out.println("子类构造方法！");
}

public void method() {  

// super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
}

}

1 package cn.itcast.day09.demo08;
2
3 public class Fu {
4
5 int num = 10;
6
7 public void method() {
8 System.out.println("父类方法");
9 }
10
11 }

1 package cn.itcast.day09.demo08;
2
3 /*
4 super关键字的用法有三种：
5 1. 在子类的成员方法中，访问父类的成员变量。
6 2. 在子类的成员方法中，访问父类的成员方法。
7 3. 在子类的构造方法中，访问父类的构造方法。
8 */
9 public class Zi extends Fu {
10
11 int num = 20;
12
13 public Zi() {
14 super();
15 }
16
17 public void methodZi() {
18 System.out.println(super.num); // 父类中的num
19 }
20
21 public void method() {
22 super.method(); // 访问父类中的method
23 System.out.println("子类方法");
24 }
25
26 }

1 package cn.itcast.day09.demo09;
2
3 public class Fu {
4
5 int num = 30;
6
7 }

package cn.itcast.day09.demo09;

/*
super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1. 在本类的成员方法中，访问本类的成员变量。

2. 在本类的成员方法中，访问本类的另一个成员方法。

3. 在本类的构造方法中，访问本类的另一个构造方法。
   在第三种用法当中要注意：
   A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
   B. super和this两种构造调用，不能同时使用。
   */
   public class Zi extends Fu {

   int num = 20;

   public Zi() {
   // super(); // 这一行不再赠送
   this(123); // 本类的无参构造，调用本类的有参构造
   // this(1, 2); // 错误写法！
   }

   public Zi(int n) {
   this(1, 2);
   }

   public Zi(int n, int m) {
   }

   public void showNum() {
   int num = 10;
   System.out.println(num); // 局部变量
   System.out.println(this.num); // 本类中的成员变量
   System.out.println(super.num); // 父类中的成员变量
   }

   public void methodA() {
   System.out.println("AAA");
   }

   public void methodB() {
   this.methodA();
   System.out.println("BBB");
   }

}

1 package cn.itcast.day09.demo10;
2
3 public class Demo {
4
5 public static void main(String[] args) {
6 Zi zi = new Zi();
7
8 zi.show();
9 zi.method();
10 }
11
12 }

1 package cn.itcast.day09.demo10;
2
3 public class Fu {
4
5 int num = 10;
6
7 public void method() {
8 System.out.println("父类方法");
9 }
10
11 }

1 package cn.itcast.day09.demo10;
2
3 public class Zi extends Fu {
4
5 int num = 20;
6
7 @Override
8 public void method() {
9 super.method(); // 调用了父类方法
10 System.out.println("子类方法");
11 }
12
13 public void show() {
14 int num = 30;
15 System.out.println(num); // 30
16 System.out.println(this.num); // 20
17 System.out.println(super.num); // 10
18 }
19
20 }

1 package cn.itcast.day09.demo11;
2
3 public class DemoMain {
4
5 public static void main(String[] args) {
6 // Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象
7
8 Cat cat = new Cat();
9 cat.eat();
10 }
11
12 }

1 package cn.itcast.day09.demo11;
2
3 /*
4 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
5 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
6
7 如何使用抽象类和抽象方法：
8 1. 不能直接创建new抽象类对象。
9 2. 必须用一个子类来继承抽象父类。
10 3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
11 覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
12 4. 创建子类对象进行使用。
13 */
14 public abstract class Animal {
15
16 // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
17 public abstract void eat();
18
19 // 这是普通的成员方法
20 // public void normalMethod() {
21 //
22 // }
23
24 }

1 package cn.itcast.day09.demo11;
2
3 public class Cat extends Animal {
4
5 @Override
6 public void eat() {
7 System.out.println("猫吃鱼");
8 }
9
10 }

1 package cn.itcast.day09.demo12;
2
3 public class DemoMain {
4
5 public static void main(String[] args) {
6 Zi zi = new Zi();
7 zi.eat();
8 }
9
10 }

1 package cn.itcast.day09.demo12;
2
3 public abstract class Fu {
4
5 public Fu() {
6 System.out.println("抽象父类构造方法执行！");
7 }
8
9 public abstract void eat();
10
11 }

1 package cn.itcast.day09.demo12;
2
3 public class Zi extends Fu {
4
5 public Zi() {
6 // super();
7 System.out.println("子类构造方法执行");
8 }
9
10 @Override
11 public void eat() {
12 System.out.println("吃饭饭");
13 }
14 }

1 package cn.itcast.day09.demo12;
2
3 /*
4 一个抽象类不一定含有抽象方法，
5 只要保证抽象方法所在的类是抽象类，即可。
6
7 这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。
8 */
9 public abstract class MyAbstract {
10 }

1 package cn.itcast.day09.demo13;
2
3 public class DemoMain {
4
5 public static void main(String[] args) {
6 // Animal animal = new Animal(); // 错误！
7
8 // Dog dog = new Dog(); // 错误，这也是抽象类
9
10 Dog2Ha ha = new Dog2Ha(); // 这是普通类，可以直接new对象。
11 ha.eat();
12 ha.sleep();
13 System.out.println("==========");
14
15 DogGolden golden = new DogGolden();
16 golden.eat();
17 golden.sleep();
18 }
19
20
21 }

1 package cn.itcast.day09.demo13;
2
3 // 最高的抽象父类
4 public abstract class Animal {
5
6 public abstract void eat();
7
8 public abstract void sleep();
9
10 }

1 package cn.itcast.day09.demo13;
2
3 // 子类也是一个抽象类
4 public abstract class Dog extends Animal {
5
6 @Override
7 public void eat() {
8 System.out.println("狗吃骨头");
9 }
10
11 // public abstract void sleep();
12 }

1 package cn.itcast.day09.demo13;
2
3 public class Dog2Ha extends Dog {
4 @Override
5 public void sleep() {
6 System.out.println("嘿嘿嘿……");
7 }
8 }

1 package cn.itcast.day09.demo13;
2
3 public class DogGolden extends Dog {
4 @Override
5 public void sleep() {
6 System.out.println("呼呼呼……");
7 }
8 }

1 package cn.itcast.day09.demo14;
2
3 import java.util.ArrayList;
4
5 public class MainRedPacket {
6
7 public static void main(String[] args) {
8 Manager manager = new Manager("群主", 100);
9
10 Member one = new Member("成员A", 0);
11 Member two = new Member("成员B", 0);
12 Member three = new Member("成员C", 0);
13
14 manager.show(); // 100
15 one.show(); // 0
16 two.show(); // 0
17 three.show(); // 0
18 System.out.println("===============");
19
20 // 群主总共发20块钱，分成3个红包
21 ArrayList redList = manager.send(20, 3);
22 // 三个普通成员收红包
23 one.receive(redList);
24 two.receive(redList);
25 three.receive(redList);
26
27 manager.show(); // 100-20=80
28 // 6、6、8，随机分给三个人
29 one.show();
30 two.show();
31 three.show();
32 }
33
34 }

1 package cn.itcast.day09.demo14;
2
3 import java.util.ArrayList;
4
5 // 群主的类
6 public class Manager extends User {
7
8 public Manager() {
9 }
10
11 public Manager(String name, int money) {
12 super(name, money);
13 }
14
15 public ArrayList send(int totalMoney, int count) {
16 // 首先需要一个集合，用来存储若干个红包的金额
17 ArrayList redList = new ArrayList<>();
18
19 // 首先看一下群主自己有多少钱
20 int leftMoney = super.getMoney(); // 群主当前余额
21 if (totalMoney > leftMoney) {
22 System.out.println("余额不足");
23 return redList; // 返回空集合
24 }
25
26 // 扣钱，其实就是重新设置余额
27 super.setMoney(leftMoney - totalMoney);
28
29 // 发红包需要平均拆分成为count份
30 int avg = totalMoney / count;
31 int mod = totalMoney % count; // 余数，也就是甩下的零头
32
33 // 除不开的零头，包在最后一个红包当中
34 // 下面把红包一个一个放到集合当中
35 for (int i = 0; i < count - 1; i++) {
36 redList.add(avg);
37 }
38
39 // 最后一个红包
40 int last = avg + mod;
41 redList.add(last);
42
43 return redList;
44 }
45 }

1 package cn.itcast.day09.demo14;
2
3 import java.util.ArrayList;
4 import java.util.Random;
5
6 // 普通成员
7 public class Member extends User {
8
9 public Member() {
10 }
11
12 public Member(String name, int money) {
13 super(name, money);
14 }
15
16 public void receive(ArrayList list) {
17 // 从多个红包当中随便抽取一个，给我自己。
18 // 随机获取一个集合当中的索引编号
19 int index = new Random().nextInt(list.size());
20 // 根据索引，从集合当中删除，并且得到被删除的红包，给我自己
21 int delta = list.remove(index);
22 // 当前成员自己本来有多少钱：
23 int money = super.getMoney();
24 // 加法，并且重新设置回去
25 super.setMoney(money + delta);
26 }
27 }

1 package cn.itcast.day09.demo14;
2
3 public class User {
4
5 private String name; // 姓名
6 private int money; // 余额，也就是当前用户拥有的钱数
7
8 public User() {
9 }
10
11 public User(String name, int money) {
12 this.name = name;
13 this.money = money;
14 }
15
16 // 展示一下当前用户有多少钱
17 public void show() {
18 System.out.println("我叫：" + name + "，我有多少钱：" + money);
19 }
20
21 public String getName() {
22 return name;
23 }
24
25 public void setName(String name) {
26 this.name = name;
27 }
28
29 public int getMoney() {
30 return money;
31 }
32
33 public void setMoney(int money) {
34 this.money = money;
35 }
36 }