【继承、抽象】
继承
继承的概述
面向对象的三大特征：封装性、继承性、多态性。
继承是多态的前提，如果没有继承，就没有多态。
继承主要解决的问题就是：共性抽取。
父类：也叫做基类、超类；
子类：也叫做派生类。
继承关系中的特点：
- 1.子类可以拥有父类的“内容”
- 2.子类还可以拥有自己专有的内容
继承的格式
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”，关系，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 Extends01 {
public static void main(String[] args) {
//创建一个子类（老师类）对象
Teacher teacher = new Teacher();
//Teacher类当中虽然什么都没写，但是继承了来自父类Employee中的method方法。
teacher.method();//我是一个员工。
//创建一个子类（助教）对象
Assistant assistant = new Assistant();
//Assistant类当中虽然什么都没写，但是继承了来自父类Employee中的method方法。
assistant.method();//我是一个员工。
}
}继承中成员变量的访问特点
在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：
- 直接通过子类对象访问成员变量
- 创建时等号左边是谁，就优先用谁，没有则向上（向父类）找
- 间接通过成员方法访问成员变量
- 方法属于谁，就优先用谁，没有则向上找
public class Fu {
int numFu = 10;
int num = 30;
public void methodFu(){
System.out.println(num);
}
}
public class Zi extends Fu {
int numZi = 20;
int num = 40;
public void methodZi(){
System.out.println(num);
}
}public class ExtendsField {
public static void main(String[] args) {
Fu fu = new Fu();//创建父类对象
System.out.println(fu.numFu);//10,只能使用父类的东西，没有任何子类的内容
Zi zi =new Zi();//创建子类对象
System.out.println(zi.numZi);//20
System.out.println(zi.numFu);//10,继承父类的成员变量
System.out.println(zi.num);//40,创建时等号左边是谁，就优先用谁，没有则向上（向父类）找
// System.out.println(zi.abc);//到处都没有，编译报错
//这个方法是子类的，优先选用子类的，没有则向上找
zi.methodZi();//40
//这个方法是在父类中定义的
fu.methodFu();//30
}
}
区分子类方法中重名的三种变量
局部变量： 直接写变量名
本类的成员变量： this.成员变量名
父类的成员变量： super.成员变量名
public class Fu {
int num = 10;
}public class Zi extends Fu {
int num = 20;
public void methodZi(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
public class ExtendsField {
public static void main(String[] args) {
Zi zi = new Zi();
zi.methodZi();
//30
//20
//10
}
}继承中成员方法的访问特点
在父子类的继承关系中，创建子类对象，访问成员方法的规则：
- 创建的对象是谁，就优先用谁的方法，没有就向上找
注意事项：
- 无论是成员方法还是成员变量，如果没有都是向上找父类，不会向下找子类的。
public class Fu {
public void method(){
System.out.println("父类方法执行！");
}
}public class Zi extends Fu {
public void method(){
System.out.println("子类方法执行！");
}
}public class ExtendsField {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}方法的重写
方法的重写（override），也叫覆写，覆盖：
概念：在继承关系当中，方法名称一样，参数列表也一样。子类的方法是对父类的方法的重写。
重写与重载的对比：
重写（override）：方法的名称一样，参数列表也一样；
重载（overload）：方法的名称一样，参数列表不一样。
注意事项：
- 1.必须保证父子类之间方法的名称相同，参数列表也相同
- @override：写在方法前面，用来检测是不是正确的覆盖重写
- 2.子类方法的返回值数据范围必须小于等于父类方法的返回值的数据范围
- 小扩展提示：java.lang.Object是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
- 3.子类方法的权限修饰符必须大于等于父类方法的权限修饰符
- public > protected > (default) > private
- 备注：(default)不是关键字defalut，而是什么都不写
public class Phone {
public void call(){
System.out.println("打电话");
}
public void message(){
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 UsePhone {
public static void main(String[] args) {
Phone phone = new Phone();
phone.call();
phone.message();
phone.show();
System.out.println("-----------");
// 打电话
// 发短信
// 显示号码
// -----------
NewPhone newPhone = new NewPhone();
newPhone.call();
newPhone.message();
newPhone.show();
System.out.println("-----------");
// 打电话
// 发短信
// 显示号码
// 显示姓名
// 显示头像
// -----------
}
}
继承中构造方法的访问特点
继承关系中，子类构造方法的访问特点：
- 1.子类构造方法当中有一个默认隐含的“super()”调用（写在最前面），所以一定是先调用父类构造方法，后执行子类构造方法
- 2.子类构造方法通过super关键字调用父类构造方法的重载有参构造方法
- 3.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()”调用
super(20);//调用父类构造方法的重载有参构造方法
System.out.println("子类构造方法！");
}
public void method(){
//super();
//错误写法，只有子类构造方法才能调用父类构造方法，子类成员方法不能调用
}
}public class Construction01 {
public static void main(String[] args) {
Fu fu = new Fu();
//父类无参构造方法！
Zi zi = new Zi();
//父类有参构造方法！
//子类构造方法！
}
}super关键字的三种用法
- 1.在子类的成员方法中，访问父类的成员变量
- 2.在子类的成员方法中，访问父类的成员方法
- 3.在子类的构造方法中，访问父类的构造方法
public class Fu {
int num =30;
public Fu(){
System.out.println("父类无参构造方法！");
}
public Fu(int num){
System.out.println("父类有参构造方法！");
}
public void method(){
System.out.println("父类成员方法");
}
}public class Zi extends Fu {
int num = 200;
public Zi(){
//super(),子类构造方法当中有一个默认隐含的“super()”调用
super(20);//调用父类构造方法的重载有参构造方法
System.out.println("子类构造方法！");
}
public void method(){
super.method();//在子类的成员方法中，访问父类的成员方法
System.out.println(super.num);//在子类的成员方法中，访问父类的成员变量
}
}this关键字的三种用法
super关键字用来访问父类内容，而this关键字用来访问本类内容，内容有三种：
- 1.在本类的成员方法中，访问本类的成员变量
- 2.在本类的成员方法中，访问本类的另一个成员方法
- 3.在本类的构造方法中，访问本类的另一个构造方法
在第三种用法当中，注意：
A.this(…)调用也必须是构造方法的第一个语句，唯一一个。
B.super()和this()两种构造调用，不能同时使用。
public class Zi extends Fu {
int num = 200;
public Zi(){
System.out.println("子类构造方法！");
}
public Zi(int num){
this();//在本类的构造方法中，访问本类的另一个构造方法
System.out.println(num+this.num);
}
public void methodA(){
System.out.println(this.num);//在本类的成员方法中，访问本类的成员变量
this.methodB();//在本类的成员方法中，访问本类的另一个成员方法
}
public void methodB(){
System.out.println("方法B");
}
}Java继承的三个特点
- 1.一个类的直接父类只能有唯一一个
- 2.Java语言可以多级继承
- 3.一个子类的直接父类是唯一的，但是一个父类可以拥有多个子类
抽象
对于父类图形，可以有很多子类：正方形、三角形、圆形。
对于每个子类都有可以具体的计算面积的方法。但是对于图形这个父类，计算面积的方法就很抽象。
如果父类当中的方法不确定如何进行{}方法体来实现，那么这就应该是一个抽象方法。
抽象方法和抽象类的格式
抽象方法，就是加上abstract关键字，然后去掉大括号，直接分号结束；
抽象类，就是抽象方法所在的类，必须是抽象类才行：在class前面加上abstract即可。
//抽象类，在class前面加上abstract
public abstract class Animal {
//这是一个抽象方法，代表吃东西，但是具体从吃什么，不确定
public abstract void eat();
//这是普通的成员方法
public void normalMethod(){
}
}抽象方法和抽象类的使用
如何使用抽象类和抽象方法：
- 1.不能直接创建new抽象类对象
- 2.必须用一个子类来继承抽象父类
- 3.子类必须覆盖重写抽象父类当中所有的抽象方法
- 覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体的大括号及内容
- 4.创建子类对象进行使用
//抽象类，在class前面加上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 Main01 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();//猫吃鱼！
}
}抽象方法和抽象类的注意事项
- 1.抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类的对象
- 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
- 2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
- 理解：子类的构造方法中，有一个默认的super()，需要访问父类构造方法。
- 3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
- 理解：未含抽象方法的抽象类，目前就是不想让调用者创建该类的对象，通常用于某些特殊的类结构设计。
- 4.抽象类的子类，必须重写抽象父类的所有抽象方法，否则，编译无法通过而报错，除非该子类也是抽象类。
- 理解：假设不重写所有的抽象方法，则该类中可能包含抽象方法，那么创建对象后，调用抽象的方法，没有意义。
发红包案例
群主发手气红包。某群有多名成员，群主给成员发手气红包。手气红包的规则：
- 1.群主的一笔金额，从群主的余额中扣除，分成n份（金额随机），让成员领取。
- 2.成员领取红包后，保存到成员余额中。
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 int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
import java.util.ArrayList;
import java.util.Random;
public class Maneger extends User {
public Maneger (String name,int money){
super(name, money);
}
public ArrayList<Integer> send(int totalMoney,int count){
ArrayList<Integer> list = new ArrayList<>();
int moneyleft = super.getMoney();
if (moneyleft < totalMoney){
System.out.println("余额不足！");
return list;
}
super.setMoney(moneyleft-totalMoney);
int r = 0;
int l =totalMoney;
for (int i = 0; i < count - 1; i++) {
r = new Random().nextInt(l);
l -=r;
list.add(r);
}
list.add(l);
return list;
}import java.util.ArrayList;
import java.util.Random;
public class Menber extends User {
public Menber(String name, int money) {
super(name, money);
}
public void receive(ArrayList<Integer> list) {
int leftmoney = super.getMoney();
int delta = list.remove(new Random().nextInt(list.size() ));
super.setMoney(leftmoney + delta);
}
}import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Maneger ceo = new Maneger("群主",100);
Menber one = new Menber("群员1",0);
Menber two = new Menber("群员2",0);
Menber three = new Menber("群员3",0);
ceo.show();
one.show();
two.show();
three.show();
System.out.println("------------");
ArrayList<Integer> list =ceo.send(20,3);
one.receive(list);
two.receive(list);
three.receive(list);
ceo.show();
one.show();
two.show();
three.show();
}
}
扫一扫
3266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
