Java_Day8 Arrays、Math,继承、抽象

Day8

Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作（如排序和搜索）。

public static String toString(数组): 返回指定数组内容的字符串的标识形式：

public static void sort(数组)：按照默认升序(从小到大)对数组的元素进行排序。

注意：

1. 如果是数值，sort默认按照升序排序
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

练习：

使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒叙打印。

public static void main(String[] args) {
    //使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒叙打印。
    Scanner sc = new Scanner(System.in);
    String line =  sc.nextLine();
    //String-->数组，用toCharArray
    char[] chars = line.toCharArray();
    //升序排列
    Arrays.sort(chars);
    for (int i = chars.length-1; i >= 0; i--) {
        System.out.print(chars[i]+ " ");
    }
}

Math

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs(double num):获取绝对值,有多种重载。

public static double ceil(double num):向上取整

public static double floor(double num):向下取整

public static long round(double num):四舍五入

Math.PI代表近似的圆周率常量（double）。

练习：

计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

public static void main(String[] args) {
    //计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
    int count = 0;
    double m = 0;
    for (double i = -10.8; i <= 5.9; i++) {
        m = Math.ceil(i);//向上取整
        double a =Math.abs(m);//取绝对值
        if (a>6 || a<2.1){
            count++;
        }
    }
    System.out.println(count);
}

继承

概述：

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

继承关系是事物之间的一种所属关系，is-a的关系。

父类更通用，而子类更具体。我们通过继承，可以是多个事物形成一种关系体系。

继承是多态的前提，如果没有继承，就没有多态

继承主要解决的问题是：共性抽取

**父类：**也可以叫基类、超类

**子类：**也可以叫派生类

继承关系当中的特点：

1. 子类可以拥有父类的"内容"
2. 子类还可以拥有自己专有的内容

格式：

父类：(一个普通的类的定义)

public class父类名称{}

子类：

public class 子类名称 extends 父类名称{}

继承的特点——成员的变量

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上找。

间接通过成员方法访问成员变量：该方法属于谁就优先用谁，没有则向上找。

public class i extends Fu{
    //Fu类中 int num = 5;
    int num = 2;
    public void show(){
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

引用变量：

在子类中

局部变量： 直接写成员变量名

本类的成员变量： this.成员变量名

父类的成员变量： 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(){
        System.out.println("子类中的show2方法");
    }
}

成员方法重名——重写(Override)

覆盖、覆写

概念：在继承关系当中，方法的名称一样，参数列表也一样

重载(Overload):方法的名称一样，参数列表不一样。

@Override
public void show(){
    super.show();
}

重写的一种应用

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

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();
    }
}

方法覆盖重写的注意事项：

1. 必须保证父子类之间方法名相同，返回值类型相同，参数列表也相同。
2. 子类方法的返回值必须小于等于父类方法的返回值范围。
3. 子类覆盖父类方法，必须保证子类中的方法权限大于等于父类的权限。(public > protected > (default) 什么都不写，留空> private )

继承特点——构造方法

1. 当构造方法的名字和类名一致的，所以子类是无法继承父类的构造
2. 构造方法就是用来创建对象，初始化成员变量，所以在类初始化的时候，子类构造方法当中有一个默认隐含的"super()"调用，所以一定是先调用父类的构造方法，后执行的子类构造
3. 可以通过super关键字来调用父类重载构造
4. super的父类构造调用，必须是子类构造方法的第一个语句

super和this关键字

每当创建子类对象的时候，先初始化父类空间（构造方法），再创建子类本身的对象。

super：代表父类的存储空间的标识

this: 代表子类的对象的引用

访问成员的时候：

this.成员变量——本类中的

super.成员变量——父类中的

this.成员方法名（）——本类

super.成员方法名（）——父类中的

super()——调用父类的构造方法

继承的特点

1. java支持单继承，不支持多继承（classA extends B,C{}//多继承）

2. java中支持多级继承

   class A extends B{}//A继承B

   class B extends C{}//B继承C

   在java中所有类的顶级父类：object类，默认继承Object类

3. 子类和父类其实是一种相对的概念

抽象类

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

定义：

​ 抽象方法：没有方法体的方法

​ 抽象类： 包含抽象方法的类

abstract//关键字

抽象方法：

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

格式：

public abstract void dog();

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

如何使用抽象类和抽象方法：

1. 必须用一个子类来继承抽象父类
2. 如果子类不是抽象类 ，子类必须覆写抽象类（父类）的所有抽象方法。
3. 抽象类可以使用子类向上转型对其实现实例化，抽象类一定不能直接实例化对象
4. 由于抽象类强制要求子类覆写父类方法，所以private 与 abstract 不能同时使用。

注意：

1. 不能直接创建new抽象类对象（抽象类中方法没有方法体，创建对象去调用无意义）。

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

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

4. 子类必须覆盖重写抽象父类当中所以的抽象方法，否则编译无法通过报错，除非子类也是一个抽象类。

   覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号