继承 、super、this、抽象类
1.继承
-
继承概述 [共性抽取来实现代码复用]
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。
-
继承格式
定义父类的格式：（一个普通的类定义）
public class 父类名称 { // ... }定义子类的格式：
public class 子类名称 extends 父类名称 { // ... } -
代码展示
// 定义一个父类：员工 public class Employee { public void method() { System.out.println("方法执行！"); } }// 定义了一个员工的子类：讲师 public class Teacher extends Employee { }// 定义了员工的另一个子类：助教 public class Assistant extends Employee { }public class Demo01Extends { public static void main(String[] args) { // 创建了一个子类对象 Teacher teacher = new Teacher(); // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。 teacher.method(); // 创建另一个子类助教的对象 Assistant assistant = new Assistant(); assistant.method(); } } -
继承中访问成员变量的访问特点
-
先来看一下下面代码
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); // 只能使用父类的东西，没有任何子类内容 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 } } -
通过上面代码不难发现:
-
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找。
-
-
-
区分三种变量重名的情况[子类的成员变量 、子类的局部变量、父类的成员变量]
-
局部变量： 直接写成员变量名
本类的成员变量： this.成员变量名
父类的成员变量： super.成员变量名 -
父类
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 Demo01ExtendsField { public static void main(String[] args) { Zi zi = new Zi(); zi.method(); } }
-
-
继承中成员方法的访问特点
规则就一条 :
在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。-
注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
父类
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：写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。 - 子类方法的返回值必须【小于等于】父类方法的返回值范围。
- 小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
- 子类方法的权限必须【大于等于】父类方法的权限修饰符。
- 小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。
- 小扩展提示：public > protected > (default) > private
- 必须保证父子类之间方法的名称相同，参数列表也相同。@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
-
重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
-
-
-
举例说明重写
-
手机拓展功能
-
代码
// 本来的老款手机 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()”调用，所以一定是先调用的父类构造，后执行的子类构造。
-
子类构造可以通过super关键字来调用父类重载构造。
-
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
-
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，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(); // 错误写法！只有子类构造方法，才能调用父类构造方法。 } }
-
-
super的用法
- 在子类的成员方法中，访问父类的成员变量。
- 在子类的成员方法中，访问父类的成员方法。
- 在子类的构造方法中，访问父类的构造方法。
-
this关键字的用法
super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：
- 在本类的成员方法中，访问本类的成员变量。
- 在本类的成员方法中，访问本类的另一个成员方法。
- 在本类的构造方法中，访问本类的另一个构造方法。
- 在第三种用法当中要注意：
A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造调用，不能同时使用。
- 在第三种用法当中要注意：
public class Fu { int num = 30; }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"); } } -
super 和 this 的图解
-
代码
-
父类
public class Fu { int num = 10; public void method() { System.out.println("父类方法"); } } -
子类
public class Zi extends Fu { int num = 20; @Override public void method() { super.method(); // 调用了父类方法 System.out.println("子类方法"); } public void show() { int num = 30; System.out.println(num); // 30 System.out.println(this.num); // 20 System.out.println(super.num); // 10 } } -
测试
public class Demo { public static void main(String[] args) { Zi zi = new Zi(); zi.show(); zi.method(); } }
-
-
图
-
-
Java 中继承的三个特点
1. 单继承
2. 多级继承
3. 一个父类可以有多个子类,反过来却不成立.
2.抽象类
-
抽象方法概述
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法 的类就是抽象类
-
通过图来声明
-
父类定义了一个方法,但是针对不同的子类却没有办法来具体实现.只有子类继承了,并重写了父类的方法,才能具体实现.这样没办法在父类统一操作实现的方法就是抽象方法.当然有抽象方法的类,就是抽象类.
-
-
定义格式
-
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
-
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
-
如何使用抽象类和抽象方法：
- 不能直接创建new抽象类对象。
- 必须用一个子类来继承抽象父类。
- 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。 - 创建子类对象进行使用。
public abstract class Animal { // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。 public abstract void eat(); // 这是普通的成员方法 // public void normalMethod() { // // } }// 必须用一个子类来继承抽象父类。 public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } }public class DemoMain { public static void main(String[] args) { // Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象 Cat cat = new Cat(); cat.eat(); } }
-
-
抽象方法和抽象类的注意事项
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。
-
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。 -
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super(),需要访问父类构造方法。public abstract class Fu { public Fu() { System.out.println("抽象父类构造方法执行！"); } public abstract void eat(); }public class Zi extends Fu { public Zi() { // super(); System.out.println("子类构造方法执行"); } @Override public void eat() { System.out.println("吃饭饭"); } } -
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计 -
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义
-
3.继承的综合案例
-
综合案例：群主发普通红包
-
群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：
1.群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
2.成员领取红包后，保存到成员余额中。
3.请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。
-
-
分析 :
-
先将共有部分进行抽取,生成一个抽象类User,共有的属性包括 : 姓名 余额 显示金额的方法.
public class User { private String name; // 姓名 private int money; // 余额，也就是当前用户拥有的钱数 public User() { } public User(String name, int money) { this.name = name; this.money = money; } // 展示一下当前用户有多少钱 public void show() { System.out.println("我叫：" + name + "，我有多少钱：" + money); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } }// 群主的类 public class Manager extends User { public Manager() { } public Manager(String name, int money) { super(name, money); } public ArrayList<Integer> send(int totalMoney, int count) { // 首先需要一个集合，用来存储若干个红包的金额 ArrayList<Integer> redList = new ArrayList<>(); // 首先看一下群主自己有多少钱 int leftMoney = super.getMoney(); // 群主当前余额 if (totalMoney > leftMoney) { System.out.println("余额不足"); return redList; // 返回空集合 } // 扣钱，其实就是重新设置余额 super.setMoney(leftMoney - totalMoney); // 发红包需要平均拆分成为count份 int avg = totalMoney / count; int mod = totalMoney % count; // 余数，也就是甩下的零头 // 除不开的零头，包在最后一个红包当中 // 下面把红包一个一个放到集合当中 for (int i = 0; i < count - 1; i++) { redList.add(avg); } // 最后一个红包 int last = avg + mod; redList.add(last); return redList; } }// 普通成员 public class Member extends User { public Member() { } public Member(String name, int money) { super(name, money); } public void receive(ArrayList<Integer> list) { // 从多个红包当中随便抽取一个，给我自己。 // 随机获取一个集合当中的索引编号 int index = new Random().nextInt(list.size()); // 根据索引，从集合当中删除，并且得到被删除的红包，给我自己 int delta = list.remove(index); // 当前成员自己本来有多少钱： int money = super.getMoney(); // 加法，并且重新设置回去 super.setMoney(money + delta); } }public class MainRedPacket { public static void main(String[] args) { Manager manager = new Manager("群主", 100); Member one = new Member("成员A", 0); Member two = new Member("成员B", 0); Member three = new Member("成员C", 0); manager.show(); // 100 one.show(); // 0 two.show(); // 0 three.show(); // 0 System.out.println("==============="); // 群主总共发20块钱，分成3个红包 ArrayList<Integer> redList = manager.send(20, 3); // 三个普通成员收红包 one.receive(redList); two.receive(redList); three.receive(redList); manager.show(); // 100-20=80 // 6、6、8，随机分给三个人 one.show(); two.show(); three.show(); } }
扫一扫
1760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
