8月05日

Arrays类

java.util.Arrays：

1、该类包含用于操作数组的各种方法（如排序和搜索）。

2、其中所有的方法都是静态的方法，所以调用起来非常方便。

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

 public class Demo {
    	public static void main(String[] args) {
    		int[] arr = {1, 3, 4, 565, 676, 23, 45, 56};
    		System.out.println(arr);
    		String string= Arrays.toString(arr);
    		System.out.println(string);
    	}
    }

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

public class Demo {
	public static void main(String[] args) {
		int[] arr = {1, 3, 4, 565, 676, 23, 45, 56};
		System.out.println("排序前："+Arrays.toString(arr));
		Arrays.sort(arr);
		System.out.println("排序后的："+Arrays.toString(arr));
	}
}

练习

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

public class Demo {
 	public static void main(String[] args) {
 		//用我们Arrays相关api，将一个随机字符串中的所有的字符升序排序。并倒序打印：
 		Scanner scanner=new Scanner(System.in);
 		String string=scanner.nextLine();
 		//将我们字符串转换我们的字符数组
 		char[] chars= string.toCharArray();
 		//将数组升序排序
 		Arrays.sort(chars);
 		//反向遍历打印一下
 		for (int i = chars.length‐1; i >=0 ; i‐‐) {
 			System.out.print(chars[i]+"‐‐");
 		}
 	}
 }

Math类

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

 public class Demo {
    	public static void main(String[] args) {
    		//public static double abs（double a）：返回一个double的绝对值
    		double d1=Math.abs(‐5); //5
    		double d2=Math.abs(5); //5
    		System.out.println(d1);
    		System.out.println(d2);
    		//public static double ceil（double a）：返回大于等于参数的最小整数
    		double d3= Math.ceil(3.3); //4
    		//public static double floor（double b）:返回小于等于参数的最大整数
    		double d4=Math.floor(3.3); //3
    		double d5=Math.floor(‐3.3);//‐4
    		//public static long round（double a）:四舍五入，返回最接近参数的long类型
    		long l=Math.round(5.5);//6
    		long l1=Math.round(5.4);//5
    	}
    }

练习：请使用Math的想换api，计算我们-10.8—5.9之间的，绝对值大于6或者小于2.1的整数有多少个。

 public class Demo {
    	public static void main(String[] args) {
    		//请使用Math的相关api，计算我们‐10.8‐‐5.9之间的，绝对值大于6或者小于2.1的整数有多少个？
    		//定义一个最小值
    		double min=‐10.8;
    		//定义一个最大值
    		double max=5.9;
    		//计算器：
    		int count=0;
    		//循环判断
    		for (double i = Math.ceil(‐10.8); i <=5.9 ; i++) {
    			//获取绝对值
    			if(Math.abs(i)>6||Math.abs(i)<2.1){
    			count++;
    		}
    	}
    	System.out.println(count+"个");
    	}
    }

继承

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

继承关系是事物之间的一种所属的关系，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 Zi extends Fu {
    	int num=2;
    	public void show(){
    	System.out.println(this.num);
    	System.out.println(super.num);
    	}
    }

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

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

成员方法重名———重写（Override）

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

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

重写的一种应用

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

public class Phone {
	public void sendMessage(){
		System.out.println("发短信！");
	}
	public void call(){
		System.out.println("打电话！");
	}
	public void show(){
	S	ystem.out.println("来电显示！");
	}
}

 public class NewPhone extends Phone{
    	//重写一下父类中的来电显示的那个方法：
    	@Override
    	public void show() {
    		//调用父类中的show方法
    		super.show();
    		System.out.println("显示名字");
    		System.out.println("显示头像");
    	}
    }

 public class Tes {
    	public static void main(String[] args) {
    		NewPhone newPhone=new NewPhone();
    		newPhone.sendMessage();
    		newPhone.call();
    		newPhone.show();
    	}
    }

注意事项：

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：代表子类的对象的引用。

访问成员的时候：

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 方法名();

  public abstract class Animal {
    	//抽象方法，没有方法
    	//抽象方法一定在抽象类中，但是抽象类中不一定都是抽象方法
    	public abstract void run();
    	public void print(){
    		System.out.println("我是抽象类里面具体实现方法！");
    	}
    }

public class Dag extends Animal{
	@Override
	public void run() {
	System.out.println("pao ‐‐‐‐‐‐");
	}
}

在我们的父类中的抽象方法，在子类中是一定要实现的。
注意事项（细节比较）：
1、抽象类不能创建对象（抽象类中方法本来就是没有方法体，你创建对象去调用没有任何意义）。

2、抽象类中，可以有构造方法，提供给子类创建对象的时候使用。

3、抽象类中不一定都是抽象方法，但是抽象方法一定在抽象类中。

4、抽象类的子类，必须重写我们抽象类中的所有的抽象方法，否则会编译报错。除非我们的子类也是一个抽象类，这个时候不用实现，直到我们子类不是抽象类的时候，去实现我们的方法。