2020-11-20day10Arrays类，Math类,继承

今日内容

1.        Array类
2.        Math类
3.        三大特征：继承

学习目标：

1. 能够解释类名作为参数和返回值类型
2. 能够写出类的继承格式
3. 能够说出继承的特点
4. 能够说出子类调用父类的成员特点

Array类

    概述：java.util.Arrays类主要是用来操作数组，里面提供了很多操作api的类，如排序和搜索功能，其所有的方法均为静态方法，调用起来非常简单。

    操作数组的方法：

          public  static  String toString(int[] a):返回指定数组的字符串表示形式。

          

public static void main(String[] args)
{
    //初始化一个int类型的数组，动态初始化只指定长度，不指定内容，而静态初始化只指定内容，不指定长度，两者不能混合使用。
   int[] arr={12,45,78,69};
    //打印数组，输出内存地址值。
   System.out.println(arr);
  
    //把数组内容转换成字符串
   String str = Arrays.toString(arr);
    //打印字符串，输出数组内容
   
   System.out.println(str);

}

public static void sort(int] arr):对指定的int数组进行数字升序排序，从小到大

public static void main(String[] args)
{
    //初始化一个int类型的数组，
   int[] arr={12,45,78,69};
    //输出排序前的内容。
   System.out.println(Arrays.toString(arr));//12,45,78,69
  
    //升序排序
   Arrays.sort(arr);

    //输出排序后的内容
   System.out.println(Arrays.toString(arr));//12,45,69,78

}

练习：对给定的任意一个字符串排序后倒序输出；

public class ArraysDome {


    public static void main(String[] args) {
        //定义一个字符串
        String  s="156451456554sjkkfjb";
        //转换为字符数组
        char[] a=s.toCharArray();
        //对字符数组进行升序排序
        Arrays.sort(a);
        //倒序输出。
        for (int  i =a.length-1;i >= 0; i--) {
            System.out.print(a[i]+" ");
        }
        //s k k j j f b 6 6 5 5 5 5 5 4 4 4 1 1
    }


}

public  static  int binarySearch(int[] arr,int key):使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。此时key指的是要搜索的值，而方法返回值声明的int 指的是搜索值对应的索引值。

使用binarySearch()方法。搜索的数组当中必须是经过升序排序的,不排序输出的结果是不准确的。

public static void main(String[] args)
{
    //定义一个int类型的数组
    int[] a={12,41,25,69,35,24};
    //排序
     Arrays.sort(a);
  
    //搜索69在a数组中得索引值
      
    int index= Arrays.binarySearch(a,69);

    System.out.println(index);//5
 
}

public static void fill(int[] arr,int val)：将指定的int 值分配给指定int数组的每个元素。

 

public static void main(String[] args)
{
     //定义一个数组;
     int[] arr={10,20,5,30,40,15,6};
     //想要把10元素分配给arr数组
     Arrays.fill(arr,10);
    //打印输出
     System.out.println(Arrays.toString(arr));//10,10,10,10,10,10,10
      
}

Math类

     概述:

          java.util.Math包含了用于执行基本数学运算的方法，如指数的幂次方，对数，平方根，三角函数等运算。里面的方法均是静态方法，并且也不需要创建对象，调用起来也是非常方便。

  基本运算的方法

         public  static double abs(double a):返回double值得绝对值。

double   d1 =  Math.abs(-5.3);//5.3
double   d2 =  Math.abs(5.3);//5.3
double   d3 =  Math.abs(0.0);//0.0

         public  static double  ceil(double a):返回大于等于参数的最小整数，往上取整。

double d1=Math.ceil(5.3);//d1的值为6.0；
double d2=Math.ceil(-5.9);//d2的值为-5.0；
double d3=Math.ceil(5.9);//d3的值为6.0；

        public static double  floor(double a):返回小于等于参数的最小整数，往下取整。

double d1=Math.floor(5.3);//d1的值为5.0；
double d2=Math.floor(5.1);//d2的值为5.0；
double d3=Math.floor(-5.9);//d3的值为-6.0；

 public static long round(double a);返回最接近参数的long类型值。（相当于四舍五入运算）。

long d1 = Math.round(-5.5);//-5
long d2 = Math.round(-5.6);//-6
long d3 = Math.round(5.5);//6
long d3 = Math.round(5.4);//5

面向对象----继承

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

概述：多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类就无需再定义这些属性和行为，只要去继承单独的类即可。

     其中，多个类称为子类，派生类，单独的那一个类称为父类，超类（superclass），基类。

  继承描述的是事物之间的所属关系，这种关系是：is-a的关系，在继承关系中，“子类就是一个父类”。也就是说，子类可以被当作父类看待。

  一般情况下，父类更通用，子类更具体，我们可以通过继承，使多种事物之间形成一种关系体系。

 定义：

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

好处：

     1.可以提高代码的复用性

     2.类与类之间可以产生一种关系，是多态的前提

继承的格式：

    通过extends关键字，可声明一个子类继承另一个父类：

    

public   class  FuClass{

     String  name;
     int      id;
     public void  work(){
   
           System.out.println("努力学习吧");

      }

}
public  class ZiClass extends  FuClass{

    //......
      public void   teach(){
      
           System.out.println(name+"在教课");

      }

}
public class Test(){

     public static void main(String[] args)
   {
         ZiClass t=new ZiClass();
         t.name="小张";
         t.teach();
         t.work();

   }



}

    继承关系当中的特点：

        1.子类可以拥有父类的“内容”；

        2.子类还可以拥有自己专有的内容；

    父类：也可以称为基类，超类。

    子类：也可以称为派生类。

继承后的特点---成员变量

      当类之间产生了关系后，其中各类中的成员变量有哪些影响？

  成员变量不重名：

     如果子类父类中定义的成员变量名字不重名，这时的访问没有任何影响。

public class  Fu{

    //定义一个变量
     int n=0;

}
public class  Zi  extends Fu{

    //定义一个子类的成员方法
     int n1=10;
      public void show()
    {
       System.out.println("父类n="+n)//0,继承来的，可以直接访问

    
    //f访问子类中的成员变量n1;
       System.out.println("子类n1="+n1)//10

    
   }

}
public  class Test{

      public static void main(String[] args)
   {

      //创建子类对象
      Zi  t=new Zi;
      //调用子类的方法
       t.show();
   }

}

成员变量重名：

     如果子类父类中出现重名的成员变量，这时的访问是有影响的。

public class  Fu{

    //定义一个变量
     int n=0;

}
public class  Zi  extends Fu{

    //定义一个子类的成员方法
     int n=20;
      public void show()
    {
       System.out.println("父类n="+n)//20 
   
    //f访问子类中的成员变量n1;   

       System.out.println("子类n="+n)//20  

    
   }

}
public  class Test{

      public static void main(String[] args)
   {

      //创建子类对象
      Zi  t=new Zi;
      //调用子类的方法
       t.show();
   }

}

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

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

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

子父类中出现了重名的成员变量时，在子类中想要访问父类中的非私有的成员变量时，需要使用super关键字，修饰父类的成员变量，类似于this操作。

   使用格式：

      super.父类的成员变量名

 子类代码中得代码需要修改

    

public class  Fu{

    //定义一个变量
     int n=0;

}
public class  Zi  extends Fu{

    //定义一个子类的成员方法
     int n=20;
      public void show()
    {
       System.out.println("父类n="+super.n)//0 
   
    //f访问子类中的成员变量n1;   

       System.out.println("子类n="+n)//20  

    
   }

}
public  class Test{

      public static void main(String[] args)
   {

      //创建子类对象
      Zi  t=new Zi;
      //调用子类的方法
       t.show();
   }

}

备注：父类中的成员变量是非私有的，子类中可以直接访问，若父类中的成员变量私有了，子类不能直接访问。

通常编码时我们遵循的是封装的原则，使用private关键字修饰成员变量，那么如何访问父类中得私有成员变量呢？可以借助于父类中的getXxx和setXxx方法。