Arrays

Arrays类

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

操作数组

public static String toString(int[] a)返回指定数组内容的字符串表现形式

public static void main(String[] args)
{
//初始化一个int类型的数组  静态初始化，只指定内容，长度系统推定
int[] arr ={1,2,5,8,56,456};
//打印数组，输出内存地址值
System.out.println(arr);//地址值
    //把数组内容转换成字符串
    String str=Arrays.toString(arr);
}

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

public static void main(String []args){
    int[] arr={1,2,5,8,56,456};
     System.out.println(Arrays.toString(arr));//排序前  [1,2,5,8,56,456] 
    
    //升序排列
    Arrays.sort(arr);
    [1,2,5,8,56,456] 
    System.out.println(Arrays.toString(arr));
}

public static int binargSearch(int[] arr,int key)

public static void main(String []args){
    //定义一个int类型的数组
    int[] arr={10,20,5,30,40,50，2，45，222};
    //搜索5这个数在arr中的索引值
    int index=Arrays.binaaySearch(arr,5);
    System.out.println("5的索引是  "+index);
}
//  5的索引是  -1

使用binarySearch（）方法，数组必须是有序的【升序】，需要先排序，得到的索引值是排序之后的新的数组的索引值，如果没有找到对应的元素值，返回一个随机负值
public static void fill(int[] a,int val)
将指定的 int 值分配给指定 int 型数组的每个元素。

public static void main(String []args){
    //定义一个int类型的数组
    int[] arr={10,20,5,30,40,50，2，45，222};
    
    //想要把100个元素值分配给arr数组
    Arrays.fill(arr,100);
    //输出
     System.out.println(Arrays.toString(arr);
}

Math类

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

基本运算的方法
public sattic double abs(double a)

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);// 6.0
double d2=Math.ceil(5.9);// 6.0
double d3=Math.ceil(-5.3); // -5

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

double d1=Math.floor(5.9);// 5.0
double d2=Math.floor(5.1);//5.0
double d3=Math.floor(-5.9);//-6.0

public static long round(double a)
返回最接近参数的long类型值

long l1=Math.round(5.5);// 6
long l2=Math.round(5.4);// 5
long l3=Math.round(-5.5);//-5  5舍6入
long l4=Math.round(-5.6);//-6

继承

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

其中，多个类称为子类或者派生类，单独的那一个类称为父类，超类，基类

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

例如：父类是员工，子类是讲师，“那么讲师就是一个员工” is-a—是一个

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

• 继承：就是子类继承父类的属性和方法，使子类对象具有与父类相同的属性、方法。子类可以直接访问父类中的【非私有】的属性和方法

  好处

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

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

继承的格式
通过extends关键字，可以声明一个子类继承一个父类

public class Fuclass{
   //....    
}
public class Ziclass extends Fuclass{
    //.... 
}

/*
定义一个员工类Employee
*/
public class Employee{
    String name;
    int id;
    //定义一个员工的工作方法
    public void work(){
        System.out.println(name+"努力工作");
    }
    
}

/*
定义一个教师类继承员工类
*/
public class Teacher extends Employee{
    
    //定义教师类中的专有方法
    public void teach(){
        
        System.out.println(name+"在讲课");
    }
    
}
/*
定义一个测试类
*/
public class Test{
    
    public static void main(String[] args){
        //创建一个讲师类
        Teacher t=new Teacher();
        //为员工name属性赋值
        t.name="张三";
        //调用yuango方法
        t.teach();
        //调用Teacher类继承过来的work()方法
        t.work();
 
    }
 
}

继承后的特点–成员变量

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

成员变量不重名的

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

public class Fu{
    //定义一个变量
    int num=10;
 
}
public class Zi extends Fu{
    //定义一个变量
    int num02=20;
    //定义一个子类的成员方法
    public void show(){
        //访问父类中的成员变量 num
        System.out.println(num);//10
        //访问子类中的成员变量 num2
        System.out.println(num2);//20
    }
    
}

public class TestExtendsField{
    
    public static void main(String[] args){
        
        Zi z=new Zi();
        //调用子类方法
        z.show();
        
    }
    
}
//10
//20

成员变量重名

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

public class Fu{
    //定义父类中的成员变量
    int num=10；
}
public class Zi extends Fu{
    
    //定义子类中的成员变量
    int num=20;
    //定义子类中的成员方法
    public void show(){
         //访问父类中的成员变量 num
        System.out.println(num);//20
        //访问子类中的成员变量 num
        System.out.println(num);//20
    }
}
// 20
// 20

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

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

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

子父类中出现了同名的成员变量时，在子类中想要访问父类中的非私有成员变量时，需要使用super

关键字，修饰父类的成员变量，类似于this
super.父类成员变量名
备注：Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类不能直接访问

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