黑马程序员-Java语言基础3

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1. 函数(掌握)

1.1函数的定义

指一段可以执行的具有特定功能的代码，小程序。

1.2函数的格式

修饰符    返回值 函数名(形参类型     形式参数1，形参类型   形式参数2…)
{
     函数体；
     return   返回值；
}

修饰符：现阶段，我们只用publicstatic

返回值类型：就是函数这段代码执行最终的结果的数据类型。

函数名：函数名称，方便我们调用，符合标识符命名规则。

参数：形参类型，数据类型；形式参数，就是接收实际参数的变量；实际参数，就是实际参与操作的变量(常量)；

1.3函数的特点

函数和函数之间是平级关系。不能再函数中定义函数。

运行特点：函数只有再被调用时才执行。

1.4案例

有返回值：求两个数的最大值。求两个数的和。比较两个数是否相等。

无返回值(void)：九九乘法表。

代码案例：

/*
1:请设计一个类Demo，这个类包含如下操作：
      A:求两个数的和。
      B:判断两个数是否相等。
      C:输出九九乘法表。
 
最后在测试类Test中进行测试。
 
2:成员变量和局部变量的区别?思考
 
一般数据我没有说什么类型，默认int类型。适用于我讲课。
*/
import java.util.*;
class Demo
{//定义一个方法，对两个数求和，返回int型的两数和。
      intgetSum(int a,int b)
      {
           returna+b;
      }
      //定义一个方法，判断两数是否相等，返回值类型为boolean。
      booleanifSame(int a,int b)
      {
           return(a==b)?true:false;
      }
      //定义一个方法，得到两个数的最大值，并输出较大者。
      intgetMax(int a,int b)
      {
           return(a>b)?a:b;
      }
      //定义一个无返回值类型的方法，输出打印九九乘法表
      voidprintChenfabiao()
      {
           for(int i=1;i<=9;i++)
           {
                 for(int j=1;j<=i;j++)
                 {
                      System.out.print(i+"*"+j+"="+i*j+"\t");
                 }
                 System.out.println();
           }
      }
}
 
class DemoTest
{   
      publicstatic void main(String[] args)
      {
           Scannerin=new Scanner(System.in);
          
           while(true)
           {
                 Demos=new Demo();
                 System.out.println("请输入两个数来求和，并判断是否相等：");
                 inta=in.nextInt();
                 intb=in.nextInt();
                 System.out.println("这两个数的和为："+s.getSum(a,b));
                 System.out.println("这两数是否相等？相等为true，不等为false："+s.ifSame(a,b));
                 System.out.println("这两个数较大的为："+getMax(a,b));
                 s.printChenfabiao();
           }
 
          
      }
}

1.5函数的调用

有明确的返回值：

单独调用：一般没有意义。

输出调用：能打印出需要的结果，但如果函数的返回值需要拿来继续操作就完蛋了……

赋值调用：推荐方式。

1.6重载函数

举例：   

  public static intsum(int a,int b){…}

          public static int sum(int a,int b,int c){…}

          public static int sum(float a,float b){…}

必须，函数名相同，参数类表不同（个数不同，类型不同）

 

2.   数组(掌握)

2.1数组的定义

存储同一种类型的多个元素的容器。

优势：数组中的元素会被自动从0开始编号，方便获取。那个编号就叫做索引。

格式：

A:int[] arr = new int[3];
B:int arr[] = new int[3];
C:int[] arr = new int[]{1,2,3};
D:int[] arr = {1,2,3};
推荐A和D。

2.2Java内存图：（用来辅助理解，最好能搞清楚）

A:栈存储局部变量使用。使用完毕，立马消失。

B:堆所有new出来的都在堆里面。

a:每一个实体都有地址值

b:每一个实体内的内容都有默认值

整数： 0

浮点数：0.0

字符： '\u0000'

布尔： false

c:在垃圾回收器空闲的时候被回收。

C:方法区

D:本地方法区

E:寄存器

2.3数组的操作：

数组的索引。arr[i](i从0开始，到arr.length-1)

数组的长度。arr.length

数组名.length

A:数组的遍历

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

B:数组获取最值(数组的排序，查找元素，二分法，冒泡法等)

二分法：

/*
需求分析：查找元素是否在数组中。
步骤：（二分法，数组前提有序）
	1.创建一个数组。
	2.通过脚标最大，最小取中间值得到一个中间（可能偏左边）。
	3.用需要查找元素与之比较，相等则输出脚标。不相等则取半再比。
	4.如果出现
*/

import java.util.*;
class FindArry
{
	static int FindArry(int key,int[] arr)
	{	
		int min=0;
		int max=arr.length-1;
		int mid=(min+max)/2;
		while (arr[mid]!=key)
		{
			if (key>arr[mid])
			{
				min=mid+1;
			}
			else
			{
				max=mid-1;
			}
			if (arr[max]<key||arr[min]>key)
			//if(min>max)
			{
				return -1;
			}
			mid=(max+min)/2;
		}
			return mid;//这里我认为我的判断条件比下面的要更效率				
	}
	public static void main(String[] args)
	{
		int[] arr={2,4,34,65,234,266,278,3456,4657};
		System.out.println(FindArry(65,arr));
	}
}

冒泡法： 

class GetMax
{//定义一个数组。
      publicstatic void main()
           {
           int[]arr=new int{1,3,4,5,2,32,4,5,2,45,6,3,322};
           for(inti=0;i<arr.length-1;i++)//冒泡法遍历数组排序
           {
                 for(intj=o;j<=i;j++)
                 {
                      if(arr[j]>arr[j+1])
                      {
                            int temp=arr[j];
                            arr[j]=arr[j+1];
                            arr[j+1]=temp;
                      }
                 }
           }//遍历排序后数组。
           for(inti=0;i<arr.length;i++)
           {
                 System.out.print(arr[i]);
           }
      }
}

2.4二维数组(理解)：

格式：

A:int[][] arr = new int[3][2];
B:int[][] arr = new int[3][];
C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

遍历：(for循环遍历)

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

应用：遍历求和。

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

-----------------------android培训、java培训、java学习型技术博客、期待与您交流！----------------------

详情请查看：http://edu.csdn.net/