java基础day7#Arrays类#Math类#继承#super和this关键字#抽象类

Arrays类：
java.util.Arrays:
该类包含用于操作数组的各种方法（如排序和搜索）
其中所有的方法都是静态的方法，所以调用起来非常方便。
public static String（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 []args):对指定的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)); 
} 
}

使用相关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类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。其中所有的方法都是静态的

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—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的关系，例如我们图中，研发部员工是属于是属于员工、父类通用，而子类更具体。我们通过继承，可以使是多个事物形成一种关系。
定义：就是子类继承父类的属性行为，使我们子类对象具有和父类相同的属性和行为，子类可以直接访问我们父类中的非私有的属性和行为。
好处：
提高代码复用性、类和类之间产生关系，十多态的前提。
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方法"); 
} 
}

p

ublic 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(){ 
System.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();
}
}
注意事项
子类覆盖父类方法，必须保证类中的方法权限大于父类的权限。
子类覆盖父类的方法，返回值类型，方法和参数列表必须一致。
继承的特点—构造方法：

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

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

构造方法的名字和类名是一致的所以子类是无法继承我们父类的构造方法
构造方法及时用来创建对象，初始化成员变量，所以在初始化的时候，子类默认先有一个super（）。默认先调用父类的构造方法，才可以给子类使用
super和this关键字：
每当我们创建子类对象的时候，先初始化我们父类的空间（构造方法），在创建子类本身的对象。
super：代表父类的存储空间标识。
this：代表子类的对象的引用。
1、访问成员的时候 t
his.成员变量—本类中的
super.成员变量—父类中的
this.成员方法名（）—本类
super.成员方法（）—父类
super()–调用父类的构造方法
继承的特点：
java只支持单继承，不支持多继承。
class A extends B{}
//单继承
class A extends B，C{}
//不可以
2、java中支持多层继承
class A extends B{}
class C extends A{}
在java中我们所有类的顶级父类。object类，默认继承父类
子类和父类其实相对的概念。
抽象类：
父类中的方法，被他的子类重写，子类各自实现都不相同，那么父类中的方法的申明和方法主题，只申明有点意义，方法体就没啥用，我们把方法成为抽象方法。java语言规定，包含抽象方法的类就是抽象类。
定义：
抽象方法：没有方法体方法
抽象类：包含抽象方法的类
abstract//关键字
使用这个关键字修饰方法，该方法就成了一个抽象方法，抽象方法只包括一个人方法名字，没有方法体。

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、抽象类的子类，必须重写我们抽象中的所有抽象方法，否则会编译报错。除非我们的子类也是一个抽象方法，这个时候不用实现，知道我们子类不是抽象类的时候，去实现我们方法。