Java基础二
方法
方法的定义
- 是语句的集合,它们在一起执行一个功能,是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建,在其它地方被引用
- 补充:一个项目应只存在一个main()方法
方法的结构
修饰符 返回值类型 方法名(参数类型 参数名){
方法体;
return 返回值;
}
- 修饰符:可选项,告诉编辑器如何调用该方法,定义了方法的访问类型
- 返回值类型:方法可能会返回值。如果没有返回值,则其类型为void
- 方法名:方法名和参数表共同构成方法签名
- 参数列表:指方法的参数类型、顺序和个数
- 参数:参数像是一个占位符,当方法被调用时,传递值给参数,这个值被称为实参或变量。参数是可选的,方法可以不包含任何参数。
- 形式参数:在方法被调用时用于接收外界输入的数据,起定义作用
- 实参:调用方法时实际传给方法的数据
- 方法体:包含具体的语句,定义该方法的功能
- return:终止方法,返回值
方法的调用
- 静态方法是和其所在类一起加载的
- 静态方法可以直接拿类名调用方法名,且在本类中可以直接用方法名调用
- 非静态方法在类实例化后才存在的
- 非静态方法需要先实例化这个类,再调用
- 对象类型 对象名 = new 对象类型()
- 对象名.方法名(实参列表)
- 静态方法是类方法,非静态是成员方法
- 当方法返回一个值时,方法调用通常被当作一个值
- 当方法返回值是void时,方法调用一定是一条语句
方法的重载
- 重载就是在一个类中,有相同的函数名称,但形参不同的函数
- 重载规则:
- 方法名称必须相同
- 参数列表必须不同
- 方法的返回类型可以相同,可以不同
- 仅仅返回类型不同不足以成为方法的重载
方法的重写
- 重写都是非静态方法的重写,和属性无关
- 子类重写父类的方法,执行的是子类的方法
- 有static,final,private不能重写
- 重写是子类重写父类的方法,要有继承关系;而重载是相对于本类的
- 重写要求:
- 方法名、参数列表必须相同
- 修饰符:范围可以扩大但不能缩小public>protected>default>private
- 抛出的异常:范围可以被缩小但不能扩大
class A {
public void test() {
System.out.println("A=>test()");
}
}
class B extends A {
public void test() {
System.out.println("B=>test()");
}
}
public class Student {
public static void main(String[] args) {
A a = new A();
a.test();
//子类重写了父类的方法
A ab = new B();
ab.test();
//B ba = new A();是错误的
}
}
/*输出结果: 若将方法都改为静态方法则结果为:
* A=>test() A=>test()
* B=>test() A=>test()
*/
//静态方法是类的方法,非静态方法是成员的方法
//静态方法时:方法的调用只和左边(定义的数据类型)有关
//对象能执行哪些方法,主要看对象左边的类型,看该类下有哪些方法
//父类型可以指向子类,但不能调用子类独有的方法
命令行传参
在运行一个程序时再传递给它消息,这要靠传递命令行参数给main()函数实现。
package com.shen.method;
public class Demo{
public static void main(String[] args){
//args.length 数组长度
for(int i=0; i<args.length; i++){
System.out.println("args["+i+"]:"+args[i]);
}
}
}
/*到命令行窗口下,进入相应的目录,执行javac Demo.java,
此时若直接执行java Demo,会出现错误:找不到或无法加载主类
多次使用命令cd .. 退到src目录下,
执行java com.shen.method.Demo this is shen
结果:args[0]:this
args[1]:is
args[2]:shen
*/
可变参数
- Java支持传递同类型的可变参数给一个方法
- 在方法声明中,在指定参数类型后加一个省略号…
- 可变的是指定参数类型的实参个数,本质是数组
- 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数,任何一个普通的参数必须在它之前声明
//打印最大值
public static void printMax(double… numbers){
double result = numbers[0];
for(int i=1; i<numbers.length; i++){
//排序
if(numbers[i]>result){
result = numbers[i];
}
}
System.out.println("The max value is "+result);
}
递归
- 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。
- 递归体:什么时候需要调用自身方法。
- 过程:前阶段——>边界——>返回阶段
//阶乘
public static int fac(int n){
if (n==1){
return 1;
}else{
return n*fac(n-1);
}
}
数组
数组的定义
- 数组是相同类型数据的有序集合
- 每一个数据称作一个数组元素,通过索引访问,索引从0开始
数组的特点
- 长度确定,一旦创建就不可变。若越界,则报:ArrayIndexOutOfBoundsException
- 其元素必须是相同类型,不允许出现混合类型
- 元素可以是任何数据类型,包括基本类型和引用类型
- 数组变量属于引用类型,数组也是对象,数组元素相当于该对象的成员变量。Java对象是在堆中,数组无论保持原始类型还是其它对象类型,数组对象本身是在堆中。
数组的声明创建
- 声明:首先必须声明数组变量,才能在程序中使用数组
dataType[] arrayRefVar;//首选方式
dataType arrayRefVar[];//效果相同
- 创建:使用new操作符来创建数组,分配了空间
dataType[] arrayRefVar = new dataType[arraySize];
数组的初始化
- 静态初始化:创建+赋值
int[] a = {1,2,3};
Man[] men = {new Man(1,1),new Man(2,2)};
- 动态初始化(包含默认初始化)
int[] a = new int[2];//默认初始化
a[0] = 1;
-
默认初始化
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中每个元素也被按照实例变量同样的方式被隐式初始化
数组的使用
//for-each循环遍历打印数组
int[] arrays = {1,2,3,4};
for (int array : arrays){
System.out.print(array+" ");
}
//for循环打印数组
public static void printArray(int[] arrays){
for (int i=0; i<arrays.length; i++){
System.out.print(arrays[i]+" ")
}
}
//此外也可以使用Arrays.toString()方法直接打印数组,首先需要import java.util.Arrays;
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for (int i=0; i<arrays.length; i++){
result[i] = int[arrays.length-i-1];
}
return result;
}
二维数组
//2行3列的二维数组
int a[][] = new int[2][3];
int[][] b = {{1,2,4},{3,5,7}};
//打印二维数组
for (int i=0; i<array.length; i++){
for (int j=0; j<array[i].length; j++){
System.out.print(array[i][j]);
}
}
Arrays类
- 数组的工具类:java.util.Arrays
- Arrays类中的方法都是static修饰的静态方法,在使用时可以直接使用类名进行调用,而不用使用对象来调用
- 常用方法:
- 数组赋值:Arrays.fill()
- 打印数组:Arrays.toString()
- 数组排序:Arrays.sort(),升序
- 比较数组元素值:Arrays.equals()
- 查找数组元素:Arrays.binarySearch(),对排序好的数组进行二分查找法操作
稀疏数组
- 当一个数组中大部分元素为0,或为同一值时,可以使用稀疏数组来保存该数组
- 处理方式:
- 记录数组一共有几行几列,除0外有多少个不同值
- 把具有不同值的行、列和值记录在一个小规模的数组中
public class Demo{
public static void main(String[] args){
//原二维数组,10行10列,2个不同值
int[][] arr1 = new int[10][10];
arr1[1][2] = 1;
arr1[3][4] = 2;
//打印稀疏数组
int[][] arr2 = xiShu(arr1);
System.out.println("稀疏数组:");
for (int i=0; i<arr2.length; i++) {
System.out.println(arr2[i][0]+"\t"+arr2[i][1]+"\t"+arr2[i][2]);
}
//还原数组
int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
for (int i=1; i<arr2.length; i++) {
arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
}
//打印还原数组
System.out.println("原数组:");
for (int[] ints : arr3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
//xiShu()方法输入原数组方法返回稀疏数组
public static int[][] xiShu(int[][] arr1){
//获取arr1数组不同值的个数
int dif = 0;
for (int i=0; i<arr1.length; i++) {
for (int j=0; j<arr1[i].length; j++){
if (arr1[i][j]!=0) {
dif++;
}
}
}
//创建稀疏数组
int[][] arr2 = new int[dif+1][3];
//稀疏数组的头部
arr2[0][0] = arr1.length;
arr2[0][1] = arr1[0].length;
arr2[0][2] = dif;
//遍历arr1数组,将非零的值信息存放在稀疏数组
int count = 0;
for (int i=0; i<arr1.length; i++) {
for (int j=0; j<arr1[i].length; j++) {
if (arr1[i][j]!=0) {
count++;
arr2[count][0] = i;
arr2[count][1] = j;
arr2[count][2] = arr1[i][j];
}
}
}
return arr2;
}
}