今日内容
- Array类
- Math类
- 三大特征:继承
学习目标:
- 能够解释类名作为参数和返回值类型
- 能够写出类的继承格式
- 能够说出继承的特点
- 能够说出子类调用父类的成员特点
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方法。