No_16_0224 Java基础学习第五天

文档版本	开发工具	测试平台	工程名字	日期	作者	备注
V1.0				2016.02.24	lutianfei	none

第三章Java基础语法
方法
方法重载
数组
Java中的内存分配
数组操作常见的两个小问题
数组练习

第三章Java基础语法

方法

• 简单的说：方法就是完成特定功能的代码块
  • 在很多语言里面都有函数的定义
  • 函数在Java中被称为方法
• 格式：

  
  
  
  

   
   
   
   
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
   
   
   
   
 函数体;
   
   
   
   
 return 返回值;
   
   
   
   
 }
  
  
  
  

• 详细解释：
  • 修饰符，目前就用public static，后详解。
  • 返回值类型：就是功能结果的数据类型。
  • 方法名：符合命名规则即可，方便我们的调用。
  • 参数：
    • 实际参数：就是实际参与运算的。
    • 形式参数：就是方法定义上的，用于接收实际参数的。
  • 参数类型：就是参数的数据类型。
  • 参数名：变量名
  • 方法体语句：就是完成功能的代码
  • return：结束方法的。
  • 返回值：就是功能的结果，由return带给调用者。

方法重载

• 方法重载概述
  • 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

• 方法重载特点

  • 与返回值类型无关，只看方法名和参数列表
  • 在调用时，虚拟机通过参数列表的不同来区分同名方法

• eg：

  
  
  
  

   
   
   
   
class FuncionTest{
   
   
   
   
 public static void main(String[] args){
   
   
   
   

   
   
   
   
 //Test1
   
   
   
   
 short b1 =3;
   
   
   
   
 short b2 =4;
   
   
   
   
 System.out.println("short:"+compare(b1,b2));
   
   
   
   

   
   
   
   
 }
   
   
   
   

   
   
   
   
//*******************************************************//
   
   
   
   
// Function :byte type
   
   
   
   
 public static boolean compare(byte a, byte b){
   
   
   
   
 System.out.println("byte type");
   
   
   
   
 return a==b;
   
   
   
   
 }
   
   
   
   

   
   
   
   
//-------------------------------------------------------//
   
   
   
   

   
   
   
   

   
   
   
   
//*******************************************************//
   
   
   
   
// Function :short type
   
   
   
   
 public static boolean compare(short a, short b){
   
   
   
   
 System.out.println("short type");
   
   
   
   
 return a==b;
   
   
   
   
 }
   
   
   
   

   
   
   
   
//-------------------------------------------------------//
   
   
   
   

   
   
   
   

   
   
   
   
//*******************************************************//
   
   
   
   
// Function :int type
   
   
   
   
 public static boolean compare(int a, int b){
   
   
   
   
 System.out.println("int type");
   
   
   
   
 return a==b;
   
   
   
   
 }
   
   
   
   

   
   
   
   
//-------------------------------------------------------//
   
   
   
   

   
   
   
   

   
   
   
   
//*******************************************************//
   
   
   
   
// Function :long type
   
   
   
   
 public static boolean compare(long a, long b){
   
   
   
   
 System.out.println("long type");
   
   
   
   
 return a==b;
   
   
   
   
 }
   
   
   
   

   
   
   
   
//-------------------------------------------------------//
  
  
  
  

数组

• 数组概念
  • 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
  • 数组既可以存储基本数据类型，也可以存储引用数据类型。

• 数组的定义格式

  • 格式1：数据类型[] 数组名;
  • 格式2：数据类型 数组名[];
  • 注意：这两种定义做完了，数组中是没有元素值的。还需对数组的元素进行初始化。

• eg：

  • A：int[] a; 定义一个int类型的数组a变量
  • B：int a[];定义一个int类型的a数组变量

• 注：

  • 1:针对数组定义两种格式，推荐使用第一种格式。因为第一种的可读性更强。第二种早期的时候确实有很多人这样用。不过，现在这样用的人越来越少了。
  • 2:作为Java的粉丝C#(Java的模仿者)就不再支持第二种语法格式了。越来越多的语言可能会抛弃第二种格式。

• 数组初始化概述：

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

• 数组的初始化方式

  • 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
  • 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度（用的更多）。

• 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

  • 格式：数据类型[] 数组名 = new 数据类型[数组长度];
  • 数组长度其实就是数组中元素的个数。
  • 举例：
    • int[] arr = new int[3];
    • 解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。new为数组分配内存空间。

Java中的内存分配

• Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
• 栈 存储局部变量，使用完毕就消失。
• 堆 存储new出来的东西
• 方法区 (面向对象部分讲)
• 本地方法区 (和系统相关)

• 寄存器 (给CPU使用)

• 局部变量

  • 在方法定义中或者方法声明上的变量
  • 使用完毕，立即消失

• 堆：new出来的东西，实体，对象。

  • a:每一个实体都有首地址值
  • b:每一个实体内的数据都有默认值
    • byte,short,int,long： 0
    • float,double： 0.0
    • char： ‘\u0000’
    • boolean： false
    • 引用类型：null
  • c:使用完毕后，会被垃圾回收器空闲的时候回收。

• 图解数组内存三个数组

  
  
  
  

   
   
   
   
/*
   
   
   
   
需求：
   
   
   
   
1、定义第一个数组，定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。
   
   
   
   
2、定义第二个数组，定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。
   
   
   
   
3、定义第三个数组，把第一个数组的地址值给它。（注意类型一致），通过第三个数组的名称去把元素重新赋值。
   
   
   
   
4、再次输出第一个数组名称和元素。
   
   
   
   
*/
   
   
   
   

   
   
   
   
class ArrayDemo{
   
   
   
   
 public static void main(String[] args){
   
   
   
   
 int[] arr = new int[3];
   
   
   
   
 arr[0] = 100;
   
   
   
   
 arr[1] = 188;
   
   
   
   
 arr[2] = 323;
   
   
   
   
 System.out.println(arr);
   
   
   
   
 System.out.println(arr[0]);
   
   
   
   
 System.out.println(arr[1]);
   
   
   
   
 System.out.println(arr[2]);
   
   
   
   

   
   
   
   
 int[] arr2 = new int[3];
   
   
   
   
 arr2[0] = 500;
   
   
   
   
 arr2[1] = 388;
   
   
   
   
 arr2[2] = 423;
   
   
   
   
 System.out.println(arr2);
   
   
   
   
 System.out.println(arr2[0]);
   
   
   
   
 System.out.println(arr2[1]);
   
   
   
   
 System.out.println(arr2[2]);
   
   
   
   

   
   
   
   
 //第三个数组
   
   
   
   
 int[] arr3 = arr;
   
   
   
   
 arr3[0] = 20;
   
   
   
   
 arr3[1] = 200;
   
   
   
   
 System.out.println(arr);
   
   
   
   
 System.out.println(arr[0]);
   
   
   
   
 System.out.println(arr[1]);
   
   
   
   
 System.out.println(arr[2]); 
   
   
   
   
 }
   
   
   
   

   
   
   
   
}
  
  
  
  

• 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

  • 格式：
    • 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
  • 举例：
    • int[] arr = new int[]{1,2,3};
    • 解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
  • 简化的写法
    • int[] arr = {1,2,3};

• 注意:不能同时进行动态初始化和静态初始化。就是不能在给定数组长度的同时给出元素。

数组操作常见的两个小问题

• 数组索引越界异常
  • ArrayIndexOutOfBoundsException 原因：访问到了数组中的不存在的索引时发生。

• 空指针异常

  • NullPointerException 原因：数组引用没有指向实体，却在操作实体中的元素时（数组已经不在堆栈内存）。

• Eg：

  
  
  
  

   
   
   
   
int[] arr = {1,2,3};
   
   
   
   
System.out.println(arr[3]); //报错：ArrayIndexOutOfBoundsException
   
   
   
   

   
   
   
   
arr = null;
   
   
   
   
System.out.println(arr[0]); //报错：NullPointerException
  
  
  
  

数组练习

• 数组遍历(依次输出数组中的每一个元素)
  • 数组属性length，可以得到数组长度。

  
  
  
  

   
   
   
   
int[] arr2 = {1,4,52,4,5,6,3,2,8,5,3,1,6,7,8,3,2};
   
   
   
   
//length 属性
   
   
   
   
for (int x=0;x<arr2.length;x++){
   
   
   
   
 System.out.println(arr2[x]);
   
   
   
   
}
  
  
  
  

• 数组获取最值(获取数组中的最大值最小值)

  
  
  
  

   
   
   
   
/*
   
   
   
   
分析：
   
   
   
   
A：从数组中人员找一个作为参照物（一般第一个），默认他是最大的。
   
   
   
   
B：遍历其他元素，一次获取和参照我进行对比。
   
   
   
   
*/
   
   
   
   

   
   
   
   
class ArrayDemo{
   
   
   
   
 public static void main(String[] args){
   
   
   
   

   
   
   
   
 int[] arr2 = {1,4,52,4,5,6,44,2,66,323,3,22,6,23,8,654,2};
   
   
   
   
 int max = arr2[0];
   
   
   
   
 int min = arr2[0];
   
   
   
   
 for (int x=1;x<arr2.length;x++){
   
   
   
   
 max = (max > arr2[x]) ? max : arr2[x];
   
   
   
   
 min = (min < arr2[x]) ? min : arr2[x];
   
   
   
   
 // System.out.println(arr2[x]);
   
   
   
   
 }
   
   
   
   
 System.out.println("Max is :" +max);
   
   
   
   
 System.out.println("Min is :" +min);
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

• 数组元素逆序 (就是把元素对调)

  
  
  
  

   
   
   
   
/*
   
   
   
   
分析：
   
   
   
   
A：将arr[0]与arr[length-1]交换
   
   
   
   
B:将arr[1]与arr[length-2]交换
   
   
   
   
...
   
   
   
   
C:只要做到arr.length/2即可
   
   
   
   
*/
   
   
   
   

   
   
   
   

   
   
   
   
class ArrayDemo{
   
   
   
   
 public static void main(String[] args){
   
   
   
   

   
   
   
   
 int[] arr = {1,4,52,4,5,6,44,2,66,323,3,22,6,23,8,654,2};
   
   
   
   

   
   
   
   
 for(int i=0;i<arr.length;i++){
   
   
   
   
 System.out.print(arr[i]+" ");
   
   
   
   
 }
   
   
   
   
 System.out.println();
   
   
   
   
 arrReverse(arr);
   
   
   
   
 for(int i=0;i<arr.length;i++){
   
   
   
   
 System.out.print(arr[i]+" ");
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   

   
   
   
   
 public static void arrReverse(int[] arr){
   
   
   
   
 for (int x=0;x<arr.length/2;x++){
   
   
   
   
 int temp = arr[x];
   
   
   
   
 arr[x] = arr[arr.length-1-x];
   
   
   
   
 arr[arr.length-1-x] = temp;
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

• 数组查表法(根据键盘录入索引,查找对应星期)

  
  
  
  

   
   
   
   
import java.util.Scanner;
   
   
   
   

   
   
   
   
class ArrayDemo{
   
   
   
   
 public static void main(String[] args){
   
   
   
   

   
   
   
   
 String[] strArr = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
   
   
   
   

   
   
   
   
 Scanner sc = new Scanner(System.in);
   
   
   
   

   
   
   
   
 System.out.println("Please input a number(0~6):");
   
   
   
   

   
   
   
   
 int index = sc.nextInt();
   
   
   
   

   
   
   
   
 System.out.println(strArr[index]);
   
   
   
   
 }
   
   
   
   
}
   
   
   
   

   
   
   
   
* 数组元素查找(查找指定元素第一次在数组中出现的索引)
  
  
  
  

来自为知笔记(Wiz)