方法、引用数据类型、ArrayList方法

1、方法的基础知识

（1）方法的语法格式：

-------------修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){

　　　　执行语句

　　　　………

　　　　return 返回值;

　　　　}

修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等，现学习阶段暂时记住static修饰符。

 返回值类型：用于限定方法返回值的数据类型void。

参数类型：用于限定调用方法时传入参数的数据类型。

参数名：是一个变量，用于接收调用方法时传入的数据。

 return关键字：用于结束方法以及返回方法指定类型的值

 返回值：被return语句返回的值，该值会返回给调用者

通过以下例子来理解：

public class MethodDemo01 {
    public static void main(String[] args) {
        int area = getArea(3, 5); // 调用 getArea方法
        System.out.println(" The area is " + area);
    }

    // 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
    public static int getArea(int x, int y) {
        int temp = x * y; // 使用变量temp记住运算结果
        return temp; // 将变量temp的值返回
    }
}

在上述代码中，定义了一个getArea()方法用于求矩形的面积，参数x和y分别用于接收调用方法时传入的高和宽，return语句用于返回计算所得的面积。在main()方法中通过调用getArea()方法，获得矩形的面积，并将结果打印。

 方法定义练习

分别定义如下方法：

定义无返回值无参数方法，如打印3行，每行3个*号的矩形

定义有返回值无参数方法，如键盘录入得到一个整数

定义无返回值有参数方法，如打印指定M行，每行N个*号的矩形

定义有返回值有参数方法，如求三个数的平均值

import java.util.Scanner;
class wubian1
{
    public static void main(String[] args) 
    {
        getxing();
        int a=getzhengshu();
        System.out.println(a);
        printstar(5,6);
        System.out.println(getavg(20,30,6));
    }
    //定义无返回值无参数方法，如打印3行，每行3个*号的矩形
    public static void getxing(){
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
        System.out.print("*");
            }
        System.out.println();
        }
    }
    //定义有返回值无参数方法，如键盘录入得到一个整数
        public static  int getzhengshu(){
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        return a;
        }
        //定义无返回值有参数方法，如打印指定M行，每行N个*号的矩形
    public static void printstar(int m,int n){
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                System.out.print("*");
            }
        System.out.println();
            }
        }
        //定义有返回值有参数方法，如求三个数的平均值
        public static double getavg(double a,double b,double c){
            double avg=(a+b+c)/3;
            return avg;
        }
    }

方法重载：

实现一个对数字求和的方法，由于参与求和数字的个数和类型都不确定，因此要针对不同的情况去设计不同的方法。接下来通过一个案例来实现对两个整数相加、对三个整数相加以及对两个小数相加的功能，具体实现如下所示：

public class MethodDemo02 {
    public static void main(String[] args) {
        // 下面是针对求和方法的调用
        int sum1 = add01(1, 2);
        int sum2 = add02(1, 2, 3);
        double sum3 = add03(1.2, 2.3);
        // 下面的代码是打印求和的结果
        System.out.println("sum1=" + sum1);
        System.out.println("sum2=" + sum2);
        System.out.println("sum3=" + sum3);
    }
    // 下面的方法实现了两个整数相加
    public static int add01(int x, int y) {
        return x + y;
    }
    // 下面的方法实现了三个整数相加
    public static int add02(int x, int y, int z) {
        return x + y + z;
    }
    // 下面的方法实现了两个小数相加
    public static double add03(double x, double y) {
        return x + y;
    }
}

Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。

下面的三个方法互为重载关系

l public static int add(int x,int y) {逻辑} //两个整数加法

l public static int add(int x,int y,int z) {逻辑} //三个整数加法

l public static int add(double x,double y) {逻辑} //两个小数加法

通过方法重载的方式进行修改，如下所示：

public class MethodDemo03 {
    public static void main(String[] args) {
        // 下面是针对求和方法的调用
        int sum1 = add(1, 2);
        int sum2 = add(1, 2, 3);
        double sum3 = add(1.2, 2.3);
        // 下面的代码是打印求和的结果
        System.out.println("sum1=" + sum1);
        System.out.println("sum2=" + sum2);
        System.out.println("sum3=" + sum3);
    }

    // 下面的方法实现了两个整数相加
    public static int add(int x, int y) {
        return x + y;
    }
    // 下面的方法实现了三个整数相加
    public static int add(int x, int y, int z) {
        return x + y + z;
    }
    // 下面的方法实现了两个小数相加
    public static double add(double x, double y) {
        return x + y;
    }
}

l 重载方法参数必须不同：

参数个数不同，如method(int x)与method(int x,int y)不同

参数类型不同，如method(int x)与method(double x)不同g

参数顺序不同，如method(int x,double y)与method(double x,int y)不同

l 重载只与方法名与参数类型相关与返回值无关

如void method(int x)与int method(int y)不是方法重载，不能同时存在

l 重载与具体的变量标识符无关

如method(int x)与method(int y)不是方法重载，不能同时存在

 参数传递：

参数传递，可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。

l ------------------定义方法时，参数列表中的变量，我们称为形式参数

l------------------ 调用方法时，传入给方法的数值，我们称为实际参数

public class ArgumentsDemo01 {
    public static void main(String[] args) {
        int a=5;
        int b=10;
        change(a, b);//调用方法时，传入的数值称为实际参数
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }

    public static void change(int a, int b){//方法中指定的多个参数称为形式参数
        a=200;
        b=500;
    }
}

public class ArgumentsDemo02 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };
        change(arr);// 调用方法时，传入的数值称为实际参数
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static void change(int[] arr) {// 方法中指定的多个参数称为形式参数
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= 2;
        }
    }
}    

----------------------------l 当调用方法时，如果传入的数值为基本数据类型（包含String类型），形式参数的改变对实际参数不影响

 2、引用数据类型

 （1）

⦁ 引用数据类型分类：

⦁ 第一种，Java为我们提供好的类，如Scanner类，Random类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。
⦁ 第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

⦁自定义数据类型概述：

类，它是引用数据类型，与之前学习的所有引用数据类型相同，自定义类也是一种数据类型。

只是自定义类型并非Java为我们预先提供好的类型，而是我们自己定义的一种引用数据类型用来描述一个事物。

⦁ 类的定义与使用：
⦁ 类的定义格式：

创建java文件，与类名相同
public class 类名{
数据类型 属性名称1；
数据类型 属性名称2；
…
}

 例如：

public class Phone 
{
    //属性
    String color;
    double size;
    String brand;
}

⦁ 类的使用格式 ：

导包：我们将所有的类放到同一个文件夹下，可以避免导包。
创建对象：数据类型 变量名 = new 数据类型();
调用方法：目前我们定义的自定义类不涉及方法，只是属性（自定义类中的方法部分在面向对象部分讲解）
访问属性：变量名.属性 (这是当前的方式，后期会采取调用方法的方式替代掉直接访问的方式来完成对属性的访问。)

上面我们新建了一个phone类，然后在下面使用

public class Test 
{
    public static void main(String[] args) 
    {
        //创建对象（实例化一个手机）
        Phone  p = new Phone();//当Test编译时Phone也编译，
        p.color = "红色";
        p.size = 5.0;
        p.brand = "iphonexs";
        System.out.println("这是一个颜色为"+p.color+"尺寸为"+p.size+"品牌为"+p.brand+"的手机");
    }
}

⦁ 自定义类型注意事项：

⦁ 通过 p.属性名 就可以对属性进行操作
⦁ 与引用类型数组类似，引用类型的自定义类型的变量，直接变量时，结果为对象地址值

3、ArrayList集合（类）方法----引用数据类型

 （1）使用格式：

导包：import java.util.ArrayList;

创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：

ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

ArrayList<引用对象> 变量名 = new ArrayList<要存储元素的数据类型>();

 注意：

l 集合中存储的元素，只能为<>括号中指定的数据类型元素；

l “<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；

下面给出8种基本数据类型所对应的引用数据类型表示形式:

基本数据类型	对应的引用数据类型表示形式
byte	Byte
short	Short
Int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

 举例说明以下：

l 存储String类型的元素

ArrayList<String> list = new ArrayList<String>();

l 存储int类型的数据

ArrayList<Integer> list = new ArrayList<Integer>();

l 存储Phone类型的数据

ArrayList<Phone> list = new ArrayList<Phone>();---------------------------存储的是phone中定义的数据类型

 （2）常用的方法：

方法声明	功能描述
boolean add（Object obj）//Object是对象	将指定元素obj追加到集合的末尾
Object get（int index）	返回集合中指定位置上的元素
int size（）	返回集合中的元素个数

方法声明	功能描述
boolean add（int index,  Object obj）	将指定元素obj插入到集合中指定的位置
Object remove（int index）	从集合中删除指定index处的元素，返回该元素
void clear（）	清空集合中所有元素
Object set（int index, Object obj）	用指定元素obj替代集合中指定位置上的元素

import java.util.ArrayList;
public class ArrayListDemo01 {
    public static void main(String[] args) {
        // 创建ArrayList集合
        ArrayList<String> list = new ArrayList<String>();
        // 向集合中添加元素
        list.add("stu1");
        list.add("stu2");
        list.add("stu3");
        list.add("stu4");
        // 获取集合中元素的个数
        System.out.println("集合的长度：" + list.size());
        // 取出并打印指定位置的元素
        System.out.println("第1个元素是：" + list.get(0));
        System.out.println("第2个元素是：" + list.get(1));
        System.out.println("第3个元素是：" + list.get(2));
        System.out.println("第4个元素是：" + list.get(3));
    }
}

ArrayList集合提供的一些常用方法，如下表：

l--------- boolean add（int index,  Object obj）

 功能：在集合中指定index（下标）位置，添加新元素obj

 功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用add(1，“javaWeb”)后，集合list中的元素为[“java”,“javaWeb”,“JavaEE”]。

l--------- Object set（int index, Object obj）

 功能：用指定元素obj替代集合中指定index位置的元素

 功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用set(0，“javaWeb”)后，集合list中的元素为[“javaWeb”,“JavaEE”]。

l--------- Object remve（int index）

 功能：从集合中删除指定index处的元素，返回该元素

 功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用remove(0)后，集合list中的元素为[“JavaEE”]，返回值为“java”。

l ---------void clear（）

 功能：清空集合中所有元素

功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用clear()后，集合list中的元素为空[]。

常用方法使用举例：

import java.util.ArrayList;//ArrayList是类
class demo05 
{
    public static void main(String[] args) 
    {
        int[] arr=new int[2];
    ArrayList<Integer>list=new ArrayList<Integer>();
        list.add(6);
        list.add(3);
        list.add(5);
        list.add(7);
        list.add(8);
        list.add(9);
        list.add(10);
        list.add(1,5);//在下标为1的数前面插入一个数
        list.remove(3);//将集合中下标为3的值删除
        //list.clear();//清楚集合中的所有数据
        list.set(0,10);//将集合中下标为0的元素换成10
        int a=list.get(0);//0是下标
        System.out.println(list.size());
        System.out.println("第1个元素是：" + list.get(0));
        for(int i=0;i<list.size();i++){
            System.out.print(list.get(i)+" ");
        }
    }
}

（3）集合的遍历 

 13import java.util.ArrayList;
 14public class ArrayListDemo02 {
 15    public static void main(String[] args) {
 16        //创建ArrayList集合
 17        ArrayList<Integer> list = new ArrayList<Integer>();
 18        //添加元素到集合
 19        list.add(13);
 20        list.add(15);
 21        list.add(22);
 22        list.add(29);
 23        //遍历集合
 24        for (int i = 0; i < list.size()[获取集合中元素的个数]; i++) {
 25            //通过索引，获取到集合中每个元素
 26            int n = list.get(i)[获取集合中指定位置上的元素值];
 27            System.out.println(n);
 28        }
 29    }
 30}

 （4）集合的几个使用小实例：

 （1）

全班同学中随机的找出一名同学，打印这名同学的个人信息。

我们对本案例进行分析，得出如下分析结果：

1.存储全班同学信息（姓名、年龄）

2.打印全班同学每一个人的信息（姓名、年龄）

3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学信息（姓名、年龄）

import java.util.ArrayList;
import java.util.Random;
class dianming 
{
    public static void main(String[] args) 
    {
        ArrayList<String> xueshengName = new ArrayList<String>();
            xueshengName.add("aaa");
            xueshengName.add("bbb");
            xueshengName.add("ccc");
            xueshengName.add("ddd");
            xueshengName.add("eee");
            xueshengName.add("fff");
        for(int i = 0;i < xueshengName.size();i++){
                System.out.print(xueshengName.get(i)+"	");
        }
        System.out.println();
        System.out.println("被选中的同学是"+chazhaoName(xueshengName));
    }
    public static String chazhaoName(ArrayList<String> xueshengName){
        Random i = new Random();
        return xueshengName.get(i.nextInt(xueshengName.size()));
    }    
}

 （2）

 

管理员能够进行的操作有3项（查看、修改、退出），我们可以采用（switch）菜单的方式来完成。

-------------库存管理------------

1.查看库存清单

2.修改商品库存数量

3.退出

请输入要执行的操作序号：

  每一项功能操作，我们采用方法进行封装，这样，可使程序的可读性增强。

选择“1.查看库存清单”功能，则控制台打印库存清单

选择“2.修改商品库存数量”功能，则对每种商品库存数进行更新

选择“3.退出”功能，则退出库存管理，程序结束

import java.util.ArrayList;
import java.util.Scanner;
class kucun1
{
    public static void main(String[] args) 
    {
        System.out.println("---------商城库存清单---------");
        System.out.println("品牌型号"+"	"+"尺寸"+"	"+"价格"+"	"+"库存");
        ArrayList<String> list=new ArrayList<String>();
        list.add("MacBookAir");
        list.add("ThinkPadT450");
        list.add("ASUS-FL5800");
        ArrayList<Double> sizes=new ArrayList<Double>();
        sizes.add(13.3);
        sizes.add(14.0);
        sizes.add(15.6);
        ArrayList<Double> price=new ArrayList<Double>();
        price.add(6988.88);
        price.add(5999.99);
        price.add(4999.5);
        ArrayList<Integer> kucun=new ArrayList<Integer>();
        kucun.add(5);
        kucun.add(10);
        kucun.add(18);
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i)+"	"+sizes.get(i)+"	"+price.get(i)+"	"+kucun.get(i));
        }
        System.out.println();
        Integer sum=0;
            for(int j=0;j<kucun.size();j++){
                sum=sum+kucun.get(j);    
        }
        System.out.println("总库存数："+sum);
        System.out.println();
        Double zongjine=0.0;
        for(int m=0;m<price.size();m++){
                zongjine=zongjine+price.get(m);
        }
        System.out.print("库存总金额："+zongjine);
        Scanner sc=new Scanner(System.in);
        while(true){
            show();
            int aa=sc.nextInt();
            switch(aa){
                case 1:chakan(list,sizes,price,kucun);
                    break;
                case 2:xiugai(list,sizes,price,kucun);
                    break;
                case 3:return;
                default:
                System.out.println("您的输入有误，请重新输入");
            }

        
        }
    }
    public static void show(){
        System.out.println("-------库存管理-----");
        System.out.println("1 查看库存清单");
        System.out.println("2 修改库存商品数量");
        System.out.println("3 退出");
        System.out.print("请输入你的选择:");
    }
    public static void chakan(ArrayList<String> list,ArrayList<Double> sizes,ArrayList<Double> price,ArrayList<Integer> kucun){
        System.out.println("--------商城库存清单----------");
        System.out.println("品牌型号"+"	"+"尺寸"+"	"+"价格"+"	"+"库存");
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i)+"	"+sizes.get(i)+"	"+price.get(i)+"	"+kucun.get(i));
        }
        System.out.println();
    }
    public static void xiugai(ArrayList<String> list,ArrayList<Double> sizes,ArrayList<Double> price,ArrayList<Integer> kucun){
        chakan(list,sizes,price,kucun);
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要修改的序号");
        int index = sc.nextInt();
        System.out.println("请输入修改后的数量");
        int num = sc.nextInt();
        kucun.set((index-1),num);
    }
    

}//zuihou