培训日记8

Arrays类：

java.util.Arrays:
该类包含用于操作数组的各种方法（如排序和搜索）。
该类包含用于操作数组的各种方法（如排序和搜索）。

public static String toString（int[] arr）:返回指定数组内容的字符串的标识形式：

public static void sort(int[] arr): :对指定的int类型的数组按数字进行升序排序

用我们Arrays相关api，将一个随机字符串中的所有的字符升序排序。并倒序打印：

Math类：

java.lang.Math :
Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。其中所有的方法都是静态的。

练习1：

请使用Math的相关api，计算我们-10.8–5.9之间的，绝对值大于6或者小于2.1的整数有多少个？

继承：

概述：
多个类当中有很多相同的属性和行为，将这些内容提取出来单独放到一个类当中，那么多个类就无需定义这些属性 和行为。只要继承一个类就可以了。

继承关系是事物之间的一种所属的关系， is-a的关系，例如我们途中，研发部员工是属于员工、 父类更通用，而子类更具体。我们通过继承，可以是多个事物形成一种关系体系。

定义：
就是子类继承父类的属性和行为，使我们子类对象具有和父类相同的属性和行为，子类可以直接访问我们父类中的 非私有的属性和行为。

好处：
1、提高代码的复用性。
2、类和类之间产生关系，是多态的前提。

格式：
class 父类{
代码
}
class 子类 extends 父类{

}

继承的特点—成员变量
当两个类之间产生了一种关系，那么各类中成员变量怎么样？ 子类和父类变量名不一致的时候：

public class Fu {
	int num = 5;
}

public class Zi extends Fu {
	int num2 = 2;
	public void show(){
		System.out.println(num);
		System.out.println(num2);

子类和父类变量名一样的怎么样？
子类和父类中出现同一个变量名，在子类中需要访问父类中非私有的成员变量时，需要使用的关键super。

继承的特点—成员方法：
如果子类和父类中出现不重名的方法，这是调用没有任何影响，对象调用方法时，会先在子类中查找有没有该方 法，如果有，那么就执行子类中的方法，如果没有，就执行父类中的方法。

public class Fu {
	int num = 5;
	public void show(){
		System.out.println("父类中的show方法");
	}
}

public class Zi extends Fu {
	int num = 2;
	public void show2() {
		Sytem.out.println("子类中的show2方法");
	}
}

成员方法重名---------重写（override）

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写。

方法重写：子类中出现和父类一模一样的方法时，（返回值类型，方法名和参数列表相同），会出现覆盖的现象， 也叫方法的重写，申明不变，重新实现。

重写的一种应用
子类根据自己的需要，定义特有的自己行为，既延续了父类的方法名称，又根据自己类的需要重新实现父类，从而 进行扩展的增强。



注意事项：
1、子类方法覆盖父类方法，必须保证子类中的方法权限大于父类的权限。
2、子类覆盖父类的方法，返回值类型，方法名和参数列表必须一致。

继承的特点—构造方法：

public class Phone {
	public Phone(){
		System.out.println("Phone的构造方法");
	}
}

public class NewPhone extends Phone{
	//重写一下父类中的来电显示的方法：
	public NewPhone(){
		//super(),系统默认加上
		super();
		System.out.println("New的构造方法！");
	}
}

1、构造方法的名字和类名是一致的，所以子类是无法继承我们父类的构造方法
2、构造方法就是用来创建对象，初始化成员变量，所以在类初始化的时候，子类默认先有一个super()，默认先调 用父类的构造方法，才可以给子类使用

super和this关键字：

每当我创建子类对象的时候，先初始化我们父类的空间（构造方法），再创建子类本身的对象。
super：代表父类的存储空间的标识。
this：代表子类的对象的引用。

1、访问成员的时候
this.成员变量—本类中的
super.成员变量—父类中的
this.成员方法名（）—本类
super.成员方法（）—父类
super()–调用父类的构造方法

继承的特点：

1.java只支持单继承，不支持多继承。
class A extends B{} //单继承
class A extends B，C{}//不可以

2、java中支持多层继承
class A extends B{}
class C extends A{}

在java中我们所有类的顶级父类：Object类，默认继承Object类
3、子类和父类其实一种相对的概念。

抽象类：

由来：
父类中的方法，被他的子类重写，子类各自实现都不相同，那么父类中的方法的申明和方法主题，，只申明有点意 义，方法体就没啥用，我们把方法体的方法称为抽象方法。java语言中规定，包含抽象方法的类就是抽象类。

定义：
抽象方法： 没有方法体的方法
抽象类：包含抽象方法的类

abstract//关键字

使用这个关键字修饰方法，该方法就成了一个抽象方法，抽方法只包括一个方法的名字，没有方法体。

格式：public abstract void run();


在我们的父类中的抽象方法，子类中一定要是实现。

注意事项：（细节比较）
1、抽象类不能创建对象（抽象类中方法本来就是没有方法体，你创建对象去调用没有任何意义）
2、抽象类中，可以有构造方法。提供给子类创建对象的时候用。
3、抽象类中不一定都是抽象方法，但是抽象方法一定在抽象类中。
4、抽象类的子类，必须重写我们抽象类中的所有的抽象方法，否则会编译报错。除非我们的子类也是一个抽象 类，这个时候不用实现，知道我们子类不是抽象类的时候，去实现我们的方法。

综合案例：发红包（不完整）

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

1. 群主的一笔金额，从群主余额中扣除，平均分成 n 等份，让成员领取。
2. 成员领取红包后，保存到成员余额中。
   
   定义用户类：

public class User {
	//成员变量
	private String username;//用户名字
	private double leftMoney;//余额

	//构造方法
	public User(){}
	//有参数的构造方法
	public User(String username,double leftMoney){
		this.username = username;
		this.leftMoney = leftMoney;
	}
	//get和set方法
	public String getUsername(){
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public double getLeftMoney() {
		return leftMoney;
	}

	public void setLeftMoney(double leftMoney) {
		this.leftMoney = leftMoney;
	}
	//余额的展示
	public void show(){
		System.out.println("用户名："+username+"余额："+leftMoney);
	}
}

定义群主类：

public class QunZ extends User{
	//构造方法
	public QunZ(){}
	//有参数的构造方法
	public QunZ(String username,double leftMoney){
		//调用父类中的有参构造
		super(username,leftMoney);
	}
	/*
	*群主方发红包：就是把一个整数的约，分成若干份
	* 1、获取群主的余额，是否够发红包，不够发返回一个null
	* 2、修改群主的余额
	* 3、拆分红包
	* 	如果能整除，那么就平均分
	* 	如果不能整除，那么余数分给最后一份
	* */
	//群主发红包
	public ArrayList<Double> send(int money,int count){
		//获取群主的余额信息
		double leftMoney=getLeftMoney();
		if(money>leftMoney){
			return null;
		}
		//修改一下群主发完红包以后的余额
		setLeftMoney(leftMoney‐money);
		//创建一个集合去保存我们的等份的金额
		ArrayList<Double> list=new ArrayList<>();
		//将钱扩大100倍，避免精度损失
		money=money*100;
		//每份的金额
		int m=money/count;
		int l=money%count;
		//前count‐1份放入我们的list集合中
		for (int i = 0; i <count‐1; i++) {
			list.add(m/100.0);
		}
		if (l==0){
			list.add(m/100.0);
		}else {
			list.add((m+l)/100.0);
		}
		return list;
	}
}