第一讲 Java函数
一、函数的概述
1、函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
格式:
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,…) {
执行语句;
return 返回值;
}
public static int add(int a,int b){}
A:修饰符 。public static(静态的方法)
B:返回值类型 这个特定的功能完成后,需要返回一个结果。这个地方就是返回结果的类型。
C:函数名 为了方便使用这个函数,给它起个名字。这个名字要符合标识符命名规则。
D:参数类型 形式参数的数据类型
**:形式参数 自定义的接收方
**:实际参数 发出方add(3,5)
E:执行语句 那么这个语句是由多条语句组成。
F:return 这个功能执行完以后,需要有一个返回值,那么这个值有关键字return带回。
2、如何定义一个函数呢?
1>、既然函数是一个独立的功能,那么给功能的运算结果是什么先明确;
2>、在明确定义该功能的过程中是否需要未知的内容参与运算
1. 明确函数返回值类型
2. 明确函数的参数列表(参数的类型和参数的个数)
3、函数的使用及注意事项
A:一般函数只有被调用后,才执行。
B:void 表示没有返回。在这个函数的结尾可以不写return。其实jvm会自动的结尾处加上return;
C:函数中不能定义函数
D:如果定义自己的函数 两个明确
明确该功能的结果 其实就是该功能的返回类型。
明确该功能的参数 其实就是明确该功能中是否需要未知内容(形式参数)参与运算。明确未知内容的类型和个数。
4、函数(方法)的重载
A:函数的重载(overload):指一个类中可以有多个方法具有相同的名字,但这些方法的参数必须不同,即或者参数的个数不同,参数的类型不同;
- 参数类型不同。int add(int i)void add(double d)
- 参数个数不同。add(int a,int b);add(int a,int b,int c)
- 参数顺序不同 print(String name, int age) //参数顺序不同的重载是可以存在的,但是没有什么实际意义
B:特点:与返回值类型无关,只看参数列表。
C:好处:便于阅读,优化程序设计。
重载的实例:
/*
什么时候用重载?
当定义的功能相同,但参与运算的未知内容不同。
那么,这时就定义一个函数名称以表示起功能,方便阅读,而通过参数列表的不同来区分多个同名函数。
*/
class FunctionOverload
{
public static void main(String[] args)
{
// add(4,5);
// add(4,5,6);
print99();
}
public static void print99(int num)
{
for(int x=1; x<=num; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
//打印99乘法表
public static void print99()
{
print99(9);
}
//定义一个加法运算,获取两个整数的和。
public static int add(int x,int y)
{
return x+y;
}
//定义一个加法,获取三个整数的和。
public static int add(int x,int y,int z)
{
return add(x,y)+z;
}
}
/*
void show(int a,char b,double c){}
a.
void show(int x,char y,double z){}//没有,因为和原函数一样。
b.
int show(int a,double c,char b){}//重载,因为参数类型不同。注意:重载和返回值类型没关系。
c.
void show(int a,double c,char b){}//重载,因为参数类型不同。注意:重载和返回值类型没关系。
d.
boolean show(int c,char b){}//重载了,因为参数个数不同。
e.
void show(double c){}//重载了,因为参数个数不同。
f.
double show(int x,char y,double z){}//没有,这个函数不可以和给定函数同时存在与一个类中。
*/
5、写一个函数实现判断两个数中最大的一个数
package cn.itcast;
public class GetMax {
/**
* 写一个函数实现求取最大值
*
* @author tsz
*
*/
public static void main(String[] args) {
int max=getMax(10,5);
System.out.println("最大的一个数:"+max);
}
private static int getMax(int x,int y)
{
return x>y?x:y;
}
}
6、定义方法实现十进制,二进制转换和十进制、十六进制转换
分析:首先熟悉进制的转换原理
class ToBin
{
public static void main(String[] args)
{
//toBin(4);
toHex(60);
//System.out.println(Integer.toBinaryString(60));
}
//十进制转换为二进制,定义方法toBin()
public static void toBin(int num)
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
//System.out.println(num%2);
sb.append(num%2);//把num%2的值通过sb存到append序列中
num=num/2;
}
System.out.println(sb.reverse());
}
/*
十进制转换为十六进制
*/
public static void toHex(int num)
{
StringBuffer sb=new StringBuffer();
for(int x=0;x<8;x++)
{
int temp=num & 15;
if(temp>9)
sb.append((char)(temp-10+'A'));//使用字符的UNcode编码
else
sb.append(temp);
num = num>>>4;
}
System.out.println(sb.reverse());
}
}
在十进制转换十六进制时,原理如图所示:
第二讲 数组
一、一维数组的概述
数组:相同类型的数据按顺序组成的一种复合数据类型,通过数组名加下标来使用数组中的数据,下标从0开始排序;
1、一维数组的定义格式:
声明一维数组:数组元素类型[] 数组名
A:当不明确数组中的元素时,动态初始化
举例 :
int[] arr = new int[3];
arr[0] = 3;
B:当明确数组中的元素时,静态初始化
举例 :
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};
2、什么时候使用数组?
当要操作的同种数据类型的数据是多个的时候,你就得想着先把这些数据用数组进行存储。
3、数组的内存图
A:栈
存储的是局部变量(在函数中定义的变量)。
变量被使用完后,立即自动释放。
B:堆
存储的是实体(数组和对象)。
实体:new出来的东西,可以存放很多数据的东西。
堆内存数据的特点
每个实体都有内存地址
堆内存中的变量都有默认初始化值
int --> 0
double --> 0.0
boolean --> false
char --> '\u0000' 空字符,unicode编码。
当实体不在被使用的时候,会在jvm空闲的时候,通过java垃圾回收机制使其自动释放。
C:方法区由static修饰
D:本地方法区 调用是Windows系统底层资源,我们不用考虑。
E:寄存器 和CPU相关。我们不用考虑。
4、数组获取最大最小值的实现
/*
给定一个数组{5,1,6,4,2,8,9}。
1,获取数组中的最大值,以及最小值。
*/
class ArrayTest
{
/*
获取数组中的最大值。
思路:
1,获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
通过一个变量进行临储。
2,让数组中的每一个元素都和这个变量中的值进行比较。
如果大于了变量中的值,就用该变量记录较大值。
3,当所有的元素都比较完成,那么该变量中存储的就是数组中的最大值了。
步骤:
1,定义变量。初始化为数组中任意一个元素即可。
2,通过循环语句对数组进行遍历。
3,在变量过程中定义判断条件,如果遍历到的元素比变量中的元素大,就赋值给该变量;
需要定义一个功能来完成。以便提高复用性。
1,明确结果,数组中的最大元素 int。、
2,未知内容:一个数组。int[]
*/
public static int getMax(int[] arr)
{
int max = arr[0];
for(int x=1; x<arr.length; x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}
/*
获取最大值的另一种方式。
可不可以将临时变量初始化为0呢?可以。这种方式,其实是在初始化为数组中任意一个角标。
*/
public static int getMax_2(int[] arr)
{
int max = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
/*
获取最小值。
*/
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
//获取double类型数组的最大值。因为功能一致,所以定义相同函数名称。以重载形式存在。
/*
public static double getMax(double[] arr)
{
int max = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
*/
public static void main(String[] args)
{
int[] arr ={5,1,6,4,2,8,9};
int max = getMax_2(arr);
int min = getMin(arr);
System.out.println("max="+max);
System.out.println("min="+min);
// boolean[] ar = new boolean[3];
// System.out.println(ar[1]);
}
}
5、数组排序(选择排序和冒泡排序)
import java.util.*;
/*
对给定数组进行排序。
{5,1,6,4,2,8,9}
*/
class ArrayTest2
{
/*
选择排序。
内循环结束一次,最值出现头角标位置上。
*/
public static void selectSort(int[] arr)
{
for (int x=0; x<arr.length-1 ; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
/*
int temp = arr[x];
arr[x] = arr[y];
arr[y]= temp;
*/
swap(arr,x,y);
}
}
}
}
/*
冒泡排序
*/
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-x-1; y++)//-x:让每一次比较的元素减少,-1:避免角标越界。
{
if(arr[y]<arr[y+1])
{
/*
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
*/
swap(arr,y,y+1);//封装
}
}
}
}
/*
发现无论什么排序。都需要对满足条件的元素进行位置置换。
所以可以把这部分相同的代码提取出来,单独封装成一个函数。
*/
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//排序前;
printArray(arr);
//排序
//selectSort(arr);
//bubbleSort(arr);
//Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中,对数组排序。要使用该句代码。
//排序后:
printArray(arr);
}
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
6、数组查找(折半查找)
必须保证这个数组是有序的
class ArrayTest1
{
public static void main(String[] args)
{
int []arr=new int[]{1,2,3,4,5,5,6,8};
//int index=getIndex(arr,3);
int index=halfSearch_2(arr,7);
System.out.println("index----="+index);
}
//实现功能,获取Key第一次出现的位置
public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
{
return x;
}
}
return -1;
}
//使用折半查找法进行查找元素,定义函数
public static int halfsearch(int[] arr,int key)
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
if(min>max){
return -1;
}
mid=(max+min)/2;
}
return mid;
}
//第二种折半的方式
public static int halfSearch_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(max+min)>>1;//这就相当于除以2
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
}
7、使用查表法实现进制的转换
class ArrayTest6
{
public static void main(String[] args)
{
// toHex(60);
toBin(-6);
}
public static void toBin(int num)
{
//定义二进制的表。
char[] chs = {'0','1'};
//定义一个临时存储容器。
char[] arr = new char[32];
//定义一个操作数组的指针
int pos = arr.length;
while(num!=0)
{
int temp = num & 1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
}
/*
0 1 2 3 4 5 6 7 8 9 A B C D E F ==十六进制中的元素。
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
查表法:将所有的元素临时存储起来。建立对应关系。
每一次&15后的值作为索引去查建立好的表。就可以找对应的元素。
这样比 -10+'a'简单的多。
这个表怎么建立呢?
可以通过数据的形式来定义。
发现终于出结果了。但是是反着的。想要正过来呢?可以通过StringBuffer reverse功能来完成。
但是这个工具还没有学习。
所以可以使用已经学习过的容器:数组来完成存储。;
*/
public static void toHex(int num)
{
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
//定义一个临时容器。
char[] arr = new char[8];
int pos = arr.length;
while(num!=0)
{
int temp = num & 15;
//System.out.println(chs[temp]);
arr[--pos] = chs[temp];
num = num >>> 4;
}
System.out.println("pos="+pos);
//存储数据的arr数组遍历。
for(int x=pos;x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}
}
二维数组
1、二维数组的格式:
格式1:int[][] arr = new int[3][2];
A:定义了名称为arr的二维数组
B:二维数组中有3个一维数组
C:每一个一维数组中有2个元素
D:一维数组的名称分别为arr[0], arr[1], arr[2]
arr:二维数组名
arr[1]:二维数组中的第二个一维数组名
arr[1][1]:二维数组中的第二个数组的第二个元素
E:给第一个一维数组1脚标位赋值为78写法是:arr[0][1] = 78;
格式2:int[][] arr = new int[3][];
A: 二维数组中有3个一维数组
B: 每个一维数组都是默认初始化值null
C: 可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[5];
arr[2] = new int[7];
格式3:int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
A:二维数组有3个一维数组。
B:
第一个一维数组有3个元素
第二个一维数组有2个元素
第三个一维数组有4个元素
2、二维数组的遍历
class Array2Demo
{
public static void main(String[] args)
{
// int[] arr = new int[3];//一维数组。
//int[][] arr = new int[3][4];//定义了名称为arr的二维数组。二维数组中有3个一维数组。
//每一个一维数组中有四个元素。
//System.out.println(arr[0][1]);
/*
int[][] arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
System.out.println(arr.length);//打印是二维数组的长度 3;
System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度
*/
int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum = 0;
for(int x=0; x<arr.length;x++)
{
for(int y=0; y<arr[x].length; y++)
{
sum = sum + arr[x][y];
}
}
System.out.println("sum="+sum);
}
}