Java中继承的定义和使用

Java的概述
面向对象的三大特征：封装性、继承性、多态性。
继承主要解决的问题就是：共性进取。

继承的格式：
在继承的关系中，“子类就是一个父类”，也就是说，子类可以被当作父类看待。
例如：子类是讲师，父类是员工类，“讲师就是一个员工”。关系：is-a

父类的定义：（也就是普通类的定义）
public class 父类名 {
// …
}

子类的定义：
public class 子类名 extends 父类名 {
// …
}

public class Test01 {

	public static void main(String[] args) {
		
		//创建一个讲师类（子类）的对象
		Teacher t = new Teacher();
		//讲师类（子类）里面虽然什么都没写，但是继承了父类里面的方法，子类对象可以使用父类里的方法
		t.method();  //方法执行啦
		
		//创建另外一个助教类（子类）的对象
		Assistant a = new Assistant();
		a.method();  //方法执`在这里插入代码片`行啦
		
	}

}

//创建一个员工类
public class Employee {
	
	public void method() {
		System.out.println("方法执行啦");	
	}

}

//创建一个员工类的子类：讲师类
public class Teacher extends Employee {
	
}

//创建另外一个子类：助教类
public class Assistant extends Employee {

}

成员变量的访问特点：
在父子类的继承关系中，如果成员变量重名，创建子类对象时，有两种访问方式：
直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找。

public class Test02 {

	public static void main(String[] args) {
		
		//创建一个父类对象
		Fu fu = new Fu();
		System.out.println(fu.numFu); //10  
		//父类对象只能使用父类中，没有任何子类内容可以使用
		
		//创建一个子类对象
		Zi zi = new Zi();
		
		System.out.println(zi.numFu);  //10
		System.out.println(zi.numZi);  //20
		
		//当父类和子类里都有num，创建对象时等号左边是谁，优先用谁
		System.out.println(zi.num);  //200 （优先用子类里的num）
		
		//这个方法是子类的，优先用子类的，没有再向上找
		zi.methodZi();  //200
		//这个方法是在父类里面定义的，属于父类
		zi.methodFu();  //100
		
	}

}

public class Fu {
	
	int numFu = 10;
	
	int num = 100;
	
	public void methodFu() {
		//使用的是本类中的num，不会向下找子类
		System.out.println(num);	
	}

}

public class Zi extends Fu {
	
	int numZi= 20;
	
	int num = 200;
	
	public void methodZi() {
		//本类当中有num，所以用的是本类中的
		System.out.println(num);	
	}
	
}

区分子类中重名的三种变量：

public class Test03 {
	public static void main(String[] args) {
		
		Zi zi = new Zi();
		zi.method();
		//30
		//20
		//10

	}	
}

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 Test04 {

	public static void main(String[] args) {
		
		Zi zi = new Zi();
		
		zi.methodFu();  //父类方法执行
		zi.methodZi();  //子类方法执行
		
		//创建了子类的对象，所以优先用子类
		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("子类重名方法执行");	
	}

}

继承中方法的覆盖重写：
重写（override）:
概念：在继承关系中，方法的名称一样，参数列表也一样。

重写（override）: 方法的名称一样，参数列表也【一样】。 覆盖、覆写
重载（overload）: 方法的名称一样，参数列表【不一样】。

覆盖重写的特点：创建的是子类对象，优先使用子类方法。

方法覆盖重写的注意事项：
1.必须保证父子类之间方法的名称相同，参数列表也相同。

@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2.子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示: java.lang.object类是所有类的公共最高父类(祖宗类)，java.lang.String就是object的子类。

3.子类方法的权限必须【大于等于】父类方法的权限修饰符。

小扩展提示: public> protected > (default) > private
备注: (default)不是关键字default， 而是什么都不写，留空。

public class PhoneTest {
	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();	
	}
	
}

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();
		System.out.println("显示名字");
		System.out.println("显示头像");
	}

继承中构造方法的访问特点：
1、子类构造方法中，有一个默认隐含的 “super( )” 调用，所以一定是先调用父类的构造，后执行子类的构造。
2、子类构造可以通过super来调用父类构造。
3、super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

总结：子类必须调用父类构造方法，如果不写则赠送super( )，写了则用写的指定的super调用，super只能有一个。

super关键字的3种用法：
1、在子类成员方法中，访问父类的成员变量。
2、在子类成员方法中，访问父类的成员方法。
3、在子类的构造方法中，访问父类的构造方法。

this关键字的3种用法：
1、在本类的成员方法中，访问本类的成员变量。
2、在本类的成员方法中，访问本类的另一个成员方法。
3、在本类的构造方法中，访问本类的另一个构造方法。
第3种用法注意：
（1）this(…)调用也必须是构造方法的第一个语句，也是唯一一个。
（2）super和this两种构造调用。不能同时使用。

public class Zi extends Fu {
	
	int num = 20;

	public void showNum() {
		int num = 30;
		System.out.println(num);        //30  局部变量
		System.out.println(this.num);   //20 成员变量
		System.out.println(super.num);  //10 父类的成员变量	
	}
	
	public void methodA() {
		System.out.println("AAA");
	}
	
	public void methodB() {
		this.methodA();
		// methodA();
		System.out.println("BBB");
	}
	
	public Zi() {
		//super();    默认不再赠送
		this(2);      //本类的无参构造，调用本类的有参构造
		//this(2,3);  错误写法
	}
	
    public Zi(int n) {
		this(2,3);
	}
    
    public Zi(int n,int m) {
		
	}
	
}

public class Fu {
	
	int num = 10;

}

继承的3个特点：



抽象的概念：


抽象方法和抽象类的格式：
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行，在class之前加上abstract即可。

如何使用抽象类和抽象方法：
1、不能直接new创建抽象类对象
2、必须用一个子类来继承抽象父类
3、子类必须覆盖重写抽象父类中的所有抽象方法
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上大括号和方法体
4、创建子类对象进行使用

抽象方法和抽象类的使用的注意事项：
1、抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用了抽象方法，而抽象方法没有具体的方法体，没有意义。

2、抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()， 需要访问父类构造方法。

3、抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4、抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法,没有意义。

群主发红包综合案例：
群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：

1.群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。

2.成员领取红包后，保存到成员余额中。

请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。

分析：


实现：

public class User {
	
	private String name;  //姓名
	private int money;    //当前用户拥有的钱数
	
	public User() {
		super();
	}

	public User(String name, int money) {
		super();
		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;
	}
}

import java.util.ArrayList;
 /**
 群主的类
 */

public class Manager extends User {
	
	public Manager() {
		
	}

	public Manager(String name, int money) {
		super(name, money);
	}
	
	public ArrayList<Integer> send(int totalMonney,int count){
		//首先创建一个数组，用来存放若干个红包的金额
		ArrayList<Integer> redlist = new ArrayList<Integer>();
		
		//首先看一下群主自己有多少钱
		int leftMoney = super.getMoney();
		if(totalMonney>leftMoney) {
			System.out.println("余额不足");
			return redlist;   //返回空集合
		}
		
		//扣钱，其实就是重新设置钱数
		super.setMoney(leftMoney-totalMonney);
		
		//发红包需要平均分成count份
		int avg = totalMonney / count;
		int mod = totalMonney % count;  //余数（也就是余下的零头）
		
		for(int i=0; i<count-1; i++ ) {
			redlist.add(avg);
		}
		
		//最后一个红包
		int last = avg+mod;
		redlist.add(last);
		
		return redlist;	
	}	

}

import java.util.ArrayList;
import java.util.Random;
  
/**
普通成员
*/

public class Member extends User {

	public Member() {
		super();
	}

	public Member(String name, int money) {
		super(name, money);
	}
	
	public void receive(ArrayList<Integer> redList) {
		//从多个红包中随机抽取一个给自己
		//随机获取一个集合当中的索引编号
		int index = new Random().nextInt(redList.size());
		
		//根据索引，从集合中删除，并且得到删除的红包给自己。
		int delta = redList.remove(index);
		
		int money = super.getMoney();  //当前成员自己本来有多少钱
		
		super.setMoney(money+delta);   //加法，重新设置钱数（本来的钱+收到的红包）
		
	}
}

import java.util.ArrayList;

public class MainRedPacket {
	public static void main(String[] args) {
		
		Manager manager = new Manager("群主",100);
		
		Member member1 = new Member("成员1",0);
		Member member2 = new Member("成员2",0);
		Member member3 = new Member("成员3",0);
		
		manager.show();
		member1.show();
		member2.show();
		member3.show();
		System.out.println("==============");
		
		//群主发红包，一共发了（）元，发了（）红包
		ArrayList<Integer> redList =manager.send(20, 3);
		//三个普通成员收红包
		member1.receive(redList);
		member2.receive(redList);
		member3.receive(redList);
		
		manager.show();
		member1.show();
		member2.show();
		member3.show();
			
	}
}

结果：