JAVA基础——方法、数组

简介: JAVA基础——方法、数组

方法


一段功能逻辑的封装,以实现重复调用。

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2 ....){
 方法体;
 return 返回值;
      }
    /*方法的格式详细说明
  (1): 修饰符    比较多,后面会详细介绍。目前使用  public static
  (2): 返回值类型    用于限定返回值的数据类型
  (3): 方法名    就是一个名称,它的存在是为了方便我们调用方法
  (4): 参数类型      限定调用方法时传入参数的数据类型
  (5): 参数名    是一个变量,接收调用方法时传入的参数
                        这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
  (6): 方法体    完成功能的代码
  (7): return   结束方法以及返回方法指定类型的值 
  (8): 返回值    就是功能的结果,由return带回,带回给调用者  */


相关说明:


1.主方法:是一个程序的入口,主方法由JVM来调用,一个类中只能有一个主方法。

格式如下:

public static void main(String args[]){
                方法体;
 }


2.方法定义在类中,方法跟方法是平级关系,不能嵌套定义。


3.方法不调用就不执行。


4.void:无明确返回值类型。如果一个方法的返回值类型是void,那么这个return可以省略。


5.如果一个方法一旦明确了返回值类型,必须由return带回一个与明确了类型一致的结果。


6.return:结束方法,并返回一个值。


7.定义在方法括号里面的参数,叫做形式参数,简称形参。形参的作用是,调用方法时,接受传过来的实参。多个形参用逗号隔开。


8.调用方法时,传入的参数叫做实际参数,简称实参。传常量、变量都可以。


9.当调用一个有参数的方法时,必须传入与之相对应的参数(参数个数和数据类型要对应)。


10.如果一个方法有返回值,我们可以调用输出,打印返回的结果。


方法有无返回值:


格式会有区别,有返回值就要有return,在调用的时候有接收


方法有无参数:


()里有参数,入口指定了类型,参数名(供提示,及方法内使用)


有参方法调用的时候,参数个数及顺序都要与形参一致!!!


方法传参的问题:


如果传的是基本类型,传的是值,跳出方法就没了


如果传的是引用类型,传的是地址,


修改引用类型的值不会因为跳出方法而消失


构造方法:


构造方法重载时,建议把默认构造方法写上


构造方法调用其他构造方法时,this(name,score);且要写在第一行


方法重载


允许一个类中,可以出现多个同名方法,只要他们的参数个数不同,或者参数类型不同,就能构成重载。


调用的时候,会根据参数个数和参数类型去匹配。


参考下题:


下列哪个答案与show不是方法重载( B )。

class Demo {
      void show(int a,int b,float c){}
    }



A.void show(int a,float c,int b){}

B.void show(int x,int y,float z){}

C.int show(int a,float c,int b){return a;}

D.int show(int a,float c){return a;}


数组


数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。


数组既可以存储基本数据类型,也可以存储引用数据类型。


格式:

格式1: 数据类型[] 数组名=new 数据类型[数据长度];
    格式2: 数据类型 数组名[]=new 数据类型[数据长度];
    /*举例:
    int[] a;  定义了一个int类型的数组a;
  int a[];  定义了一个int类型的a数组;
  推荐使用第一种定义方式。*/

相关性质:


数组的定义语法:分为两种,动态定义(由我们规定数组的长度,由系统赋默认值:short、byte、long、int-0;boolean-false;float、double-0.0)和静态定义(由我们赋默认值,由系统规定数组的长度)。


注意事项: 这两种方式,只能使用一种,不能进行动静结合。


Java中的数组必须先初始化才能使用。初始化就是为数组中的数组元素分配内存空间,并为每个数组元素赋值。


数据的使用,涉及栈内存、堆内存、方法区之间的互相调用(多个引用可以指向同一个空间)。

例子如下:

public class ArrayDemo2 {
        public static void main(String[] args) {
            int[] arr1 = new int[3];
            arr1[0]=10;
            arr1[2]=200;
            int[] arr2 = new int[3];
            arr2[0]=11;
            arr2[1]=19;
            int[] arr3=arr1;
            arr3[0]=108;
            arr3[1]=106;
            arr1[1]=177;
            System.out.println(arr1[0]); // 108
            System.out.println(arr1[1]); // 177
            System.out.println(arr1[2]); // 200
            System.out.println(arr2[0]); // 11
            System.out.println(arr2[1]); // 19
            System.out.println(arr2[2]); // 0
            System.out.println(arr3[0]); // 108
            System.out.println(arr3[1]); // 177
            System.out.println(arr3[2]); // 200
        }
        }


定义第一个数组,定义完毕后,给数组元素赋值。赋值完毕后,再输出数组名称和元素。


定义第二个数组,定义完毕后,给数组元素赋值。赋值完毕后,再输出数组名称和元素。


定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致),通过第三个数组的名称去把元素重新赋值。


最后,再次输出第一个数组数组名称和元素。


数组的长度属性:length,数组中最后一个元素的索引:length(数组长度)-1。


数组的异常:数组角标越界异常(数组一旦定义好,长度就固定了),空指针异常(数组名 = null,人为置空)。


数组的遍历:利用for循环

代码如下:

public class ArrayDemo {
            public static void main(String[] args) {
                int[] arr={10,20,50,40,102};
                //数组的遍历
                //for(int i=0;i<arr.length;i++){
                //    System.out.println(arr[i]);
                //}
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }
                System.out.println("---------------------------");
                //反向遍历
                for(int i=arr.length-1;i>=0;i--){
                    System.out.println(arr[i]);
                }
            }
        }

 

获取数组中的最大值或最小值


代码如下:

public class ArrayDemo2 {
         public static void main(String[] args) {
            //获取数组中的最大值或最小值
             int[] arr = {10, 20, 50, 40, 102};
             int max = getMax(arr);
             System.out.println("最大值是" + max);
             int[] arr2 = {10, 20, 50, 40, 102,1000,1};
             int max1 = getMax(arr2);
             System.out.println("最大值是" + max1);
         }
         public static int getMax(int[] arr){
             //定义一个参照值
             int max = arr[0];
             for (int i = 1; i < arr.length; i++) {
                 if (arr[i] > max) {
                     max = arr[i];
                 }
             }
             return max;
         }
     }

 

调转数组中的元素(首尾元素交换,遍历一半)


代码如下:

public class ArrayDemo3 {
     public static void main(String[] args) {
         //A:
         //案例演示:
         //数组元素反转(就是把元素对调)
         int[] arr = {10, 20, 30, 40, 50}; //50 40 30 20 10
         for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
             int t = arr[i];
             arr[i] = arr[j];
             arr[j] = t;
         }
         //reverseArray(arr);
         showArray(arr);
     }
     //数组元素反转
     private static void reverseArray(int[] arr) {
         //分析:首尾元素值交换,遍历一半
         for (int i = 0; i < arr.length / 2; i++) {
             //采用中间变量进行值交换
             int t = arr[i];
             arr[i] = arr[arr.length - 1 - i];
             arr[arr.length - 1 - i] = t;
         }
     }
     private static void showArray(int[] arr) {
         for (int i = 0; i < arr.length; i++) {
             System.out.print(arr[i] + ",");
         }
     }
 }


数组元素、索引的分别查找


代码如下:


(1)输入索引,寻找数组元素:

public class ArrayDemo8 {
         public static void main(String[] args) {
             //A:
             //案例演示:
             //数组查表法(根据键盘录入索引, 查找对应星期)
             //根据索引查元素
             //获取跟打印输出是两个概念
             String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
             Scanner scanner = new Scanner(System.in);
             System.out.println("请输入一个整数 1----7");
             int index = scanner.nextInt();
             String str = getElementByArray(index, arr);
             System.out.println(str);
         }
         private static String getElementByArray(int index, String[] arr) {
             if (index >= 1 && index <= 7) {
                 return arr[index - 1];
             } else {
                 return "查无此元素";
             }
         }
     }


(2)输入数组元素,寻找索引:

public class ArrayDemo9 {
    public static void main(String[] args) {
        //ctrl+alt+O 优化导包,没有的包导进来,没有用到的包删掉
        //根据元素查索引
        String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个星期");
        String str = scanner.nextLine();//获取用户输入的字符串
        int index = getIndex(str, arr);
        System.out.println("该元素的索引是" + index)
    }
    private static int getIndex(String str, String[] arr) {
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (str.equals(arr[i])) {
                return i;
            }
        }
        return -1; // 一般喜欢用 -1 代表没找到
    }
}

Arrays类:实用类,对数组使用


equals Arrays.equals(数组名1,数组名2) //比较两个数组是否具有相同的值


sort Arrays.sort() //升序排序


toString Arrays.toString() //遍历数组所有元素


fill Arrays.fill(数组名,值) //把数组所有元素填充为同一个值


copyOf Arrays.copyOf(数组名,长度)


// 长度与原数组相同的就直接复制该数组,

// 如果长度大于原数组,在后面补对应类型的默认值

// 如果长度小于原数组,从原数组开始截取


binarySearch Arrays.binarySearch(数组名,值) //对一个已经升序排列的数组,查找值所在的下标,如果为负数,则表示没查到


目录
相关文章
|
18天前
|
存储 Java 程序员
Java基础的灵魂——Object类方法详解(社招面试不踩坑)
本文介绍了Java中`Object`类的几个重要方法,包括`toString`、`equals`、`hashCode`、`finalize`、`clone`、`getClass`、`notify`和`wait`。这些方法是面试中的常考点,掌握它们有助于理解Java对象的行为和实现多线程编程。作者通过具体示例和应用场景,详细解析了每个方法的作用和重写技巧,帮助读者更好地应对面试和技术开发。
67 4
|
29天前
|
Java API
Java 对象释放与 finalize 方法
关于 Java 对象释放的疑惑解答,以及 finalize 方法的相关知识。
48 17
|
23天前
|
Java 测试技术 Maven
Java一分钟之-PowerMock:静态方法与私有方法测试
通过本文的详细介绍,您可以使用PowerMock轻松地测试Java代码中的静态方法和私有方法。PowerMock通过扩展Mockito,提供了强大的功能,帮助开发者在复杂的测试场景中保持高效和准确的单元测试。希望本文对您的Java单元测试有所帮助。
63 2
|
1月前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
20 3
|
1月前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
19 2
|
1月前
|
安全 Java
Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧
【10月更文挑战第20天】Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧,包括避免在循环外调用wait()、优先使用notifyAll()、确保线程安全及处理InterruptedException等,帮助读者更好地掌握这些方法的应用。
19 1
|
1月前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
34 1
|
1月前
|
Java
在Java多线程编程中,`wait()`和`notify()`方法的相遇如同一场奇妙的邂逅
在Java多线程编程中,`wait()`和`notify()`方法的相遇如同一场奇妙的邂逅。它们用于线程间通信,使线程能够协作完成任务。通过这些方法,生产者和消费者线程可以高效地管理共享资源,确保程序的有序运行。正确使用这些方法需要遵循同步规则,避免虚假唤醒等问题。示例代码展示了如何在生产者-消费者模型中使用`wait()`和`notify()`。
28 1
|
1月前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法,并分享了最佳实践,帮助开发者避免常见陷阱,提高多线程程序的稳定性和效率。
38 1
|
24天前
|
Java Spring
JAVA获取重定向地址URL的两种方法
【10月更文挑战第17天】本文介绍了两种在Java中获取HTTP响应头中的Location字段的方法:一种是使用HttpURLConnection,另一种是使用Spring的RestTemplate。通过设置连接超时和禁用自动重定向,确保请求按预期执行。此外,还提供了一个自定义的`NoRedirectSimpleClientHttpRequestFactory`类,用于禁用RestTemplate的自动重定向功能。
下一篇
无影云桌面