Java语言入门（三）——Java方法与数组

方法

1 方法的重载:
(1)方法名相同.
(2)形式参数一定不同(参数个数不同；参数类型不同)。
2 形参一定在栈内存里，调用完成，生命周期结束。
3 方法重载与返回类型无关，但一般设置相同的返回类型，以体现方法重载的特点。
4 方法中不允许嵌套定义，只能调用其他的方法。

class Test-3.1
{
   public static void main(String[] args) 
   {  int x=add(10,20);
      System.out.println(x);     //30
      x=add(10,20,30);
      float y=add(10,20f);
     System.out.println("x="+x+”,"+"y="+y);    //x=60,y=30.0
   }
   static int add(int x,int y)
   {return x+y;}
   static int add(int x,int y,int z)
   {return x+y+z;}
   static float add(int x,float y)
   {return x+y;}
}

数组

1 数组是一种引用类型，在内存中连续存储，开辟了栈内存和堆内存。用new来创建，数组的大小在堆内存中申请；引用数组元素通过数组名【下标】，且数组的释放由java虚拟机完成。
2 开辟数组空间会赋默认值（new 用于开启空间，开启一个堆空间）
3 数组越界可通过编译，但运行时报错ArryIndexOutofBoundsException
4 对数组静态赋值时不要声明数组大小，否则无法通过编译。因为声明是在栈内存里进行的，大小由堆内存决定。声明时堆内存里的大小还没开辟出来，因此不可在声明时指明数组大小。
5 数组声明后不能被访问，因为未为数组元素分配内存空间，即未new。
6 格式：数组类型 数组名字= new 数组元素的类型[数组元素的个数]。
7 int [] a=null;//在栈内存内存放一个a地址
a=new int[10];//在堆内存内开辟10个int型的空间，并进行赋值
以上两个语句相当于 int a[]=new int[10]
8 (NullPointerException)空指针异常。堆内存内的数据变成垃圾。

class Test-3.2
{
   public static void main(String[] args) 
  {    
     //int x[5]={1,2,3,4,5};error
    int[] a=new int[] {1,2,3,4,5};//静态赋值
    /* int [] a={1,2,3,4,5};true
     for(int i=0;i<10;i++)
     {System.out.print(a[i]+",");越界*/
      /*a=null;	空指针异常*/
      a[4]=10; //动态赋值
      for(int i=0;i<a.length;i++)
      {System.out.print(a[i]+",");}     //1,2,3,4,10
/*a.length为属性，不是方法！！!*/
  }
}  

常用的数组方法

1 数组排序函数（java.util.Arrays.sort()）

class Test-3.3
{
   public static void main(String[] args) 
  {
     int [] a=new int[]{1,20,3,14,5,23,11};
     java.util.Arrays.sort(a);
     for(int i=0;i<a.length;i++)
     {System.out.print(a[i]+",");}    //1，3，5，11，14，20，23
  }
}

2 数组复制函数(System.arraycopy())

class Test-3.4
{
   public static void main(String[] args) 
  {
     int [] a=new int[]{1,20,3,14,5,23,11};   
     int y[]=new int[12];
     System.arraycopy(a,1,y,2,3);    //复制a[1]到y[2],依次复制3次。
     for(int i=0;i<a.length;i++)
     {System.out.print(y[i]+",");}   //0,0,20,3,14,0,0,
  }
}

3 引用的传递

class Test-3.5
{
   public static void main(String[] args) 
  {
     int []a=new int[]{1,2,3,8};
//a、x为引用型变量
     int []x=a;//引用的传递;句柄==引用
     for(int i=0;i<x.length;i++)
     {System.out.println(x[i]+",");}    //1,2,3,8,
    }
}

二维数组

class Test-3.6
{
   public static void main(String[] args) 
    {int [][]a=new int[2][3];
     for(int i=0;i<a.length;i++)
       {for(int j=0;j<a[i].length;j++)
         {System.out.print(a[i][j]+",");}      //0,0,0,
       System.out.println("\n");}              //0,0,0,
   }
}

class Test-3.7  //不规则二维数组
{
   public static void main(String[] args) 
    {int [][]a=new int[3][];
      a[0]=new int[2];
      a[0][0]=1;a[0][1]=2;
      a[1]=new int[1];
      a[1][0]=3;
      a[2]=new int[3];
      a[2][0]=4;a[2][1]=5;a[2][2]=6;
      for(int i=0;i<a.length;i++)
      {for(int j=0;j<a[i].length;j++)        //1,2,
         {System.out.print(a[i][j]+",");}    //3,
         System.out.println("\n");}          //4,5,6
    }
}

数组与方法的联系

1 数组可以作为参数传递。
2 数组可以作为方法返回值类型。
3 数组可以改变原数组的值。

class Test-3.8
{
   public static void main(String[] args) 
    {
       int []a=fun();  
//数组a指向fun方法返回的数组
      print(a);	
     }
      static void print(int [] a) 	
        {for (int i=0;i<a.length ;i++ )
          {System.out.print(a[i]+" ");}}     //2 4 6 8
       static int[] fun()		
          {int []a=new int[] {2,4,6,8};
	return a; } 
//此处a为地址，相当于一个指针
}

foreach语句

1 java1.5新特性。加强的for循环，foreach主要是针对数组，集合。
2 语句格式：for(元素类型t 元素变量x : 遍历对象obj){引用了x的java语句;}

class Test-3.9
{
   public static void main(String [] args)
   {
      int []a={1,3,5,7,9};
      change(a);
      for (int i:a )
      {System.out.print(i+" ");}   //12 3 5 100 9
    }
  static void change(int [] a)
   {
      a[0]=12;a[3]=100;
      return ;
   }
}

class Test-3.10
{
   public static void main(String [] args)
   {
      int []a={1,3,5,7,9};
      change(a);
      for (int i:a )  //打印数组的地址，五个相同地址     //[I@de6ced 
      {System.out.print(a+" ");}                    //[I@de6ced 
    } //a是数组的引用，即地址值，语句中变化的是i          //[I@de6ced 
  static void change(int [] a)                     //[I@de6ced 
   {                                               //[I@de6ced 
      a[0]=12;a[3]=100;
      return ;
   }
}

与键盘进行交互的方法

(1) Sytem.in.read(); 返回的是输入数值的 ASKII 码

import java.io.*;
public static void main(String [] args) throws IOException
{ 
         System.out.print("Enter a Char:"); 
         char i = (char) System.in.read(); 
         System.out.println("your char is :"+i); 
} 

System.in.read()只能针对一个字符的获取，同时，获取进来的变量的类型只能是char，当输入一个数字，希望得到的也是一个整型变量的时候，还得修改其中的变量类型
每次只是读取一个字符。返回值为输入数值的ASCII码，该值为0到 255范围内的int字节值。如果是char 则输出单字符。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
(2) 命令行参数 args()
(3) Scanner类

import java.util.Scanner;
public static void main(String [] args) 
{ 
         Scanner sc = new Scanner(System.in); 
         System.out.println("请输入你的姓名："); 
         String name = sc.nextLine(); 
         System.out.println("请输入你的年龄："); 
         int age = sc.nextInt(); 
         System.out.println("请输入你的工资："); 
         float salary = sc.nextFloat(); 
         System.out.println("你的信息如下："); 
         System.out.println("姓名："+name+"\n"+"年龄："+age+"\n"+"工资："+salary); 
}

注意
若改动代码，先执行nextInit()再执行nextLine()，在输入年龄，敲击enter键后，将跳过了输入姓名，直接到了输入工资这里。
原因是在执行nextInt()函数之后，敲击了enter回车键，回车符会被nextLine()函数吸收，实际上是执行了nextLine()函数吸收了输入的回车符。
在java中，next()方法是不接收空格的，在接收到有效数据前，所有的空格或者tab键等输入被忽略，若有有效数据，则遇到这些键退出。nextLine()可以接收空格或者tab键，其输入应该以enter键结束。
(4) BufferedReader、InputStreamReader 类

import java.io.*;
public static void main(String [] args) throws IOException
{ 
           BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
           String str = null; 
           System.out.println("Enter your value:"); 
           str = br.readLine(); 
           System.out.println("your value is :"+str); 
}

从控制台接收一个字符串，然后将其打印出来。

注：在读取输入的字符时，有可能出现异常，所以必须用try••••catch语句或者throws IOException捕获异常。否则不能通过编译。