函数(方法)
定义:如果一个功能的代码要被复用起来,那么这时候可以把这里的功能代码封装起来,在java中把功能代码封装起来的是以函数的形式体现的。
函数的格式:
修饰符 返回值类型 函数名(形式参数.....){
需要被封装的功能代码;
return 结果;
}
例如:
public static int add(){
int a=2;
int b=3;
return a+b;
}
分析函数:
修饰符:public static
返回值类型:int 返回值类型就是指函数运行完毕后,返回结果的数据类型。
注意: 某些函数是没有结果返回给调用者的,那么这时候返回值类型是void。
函数名:add
函数名的作用:如果需要调用该函数就需要使用的函数名。 函数名只要符合标识符的命名规则即可。
函数名的命名规范: 首单词全部小写,其他单词的首字母大写,其他小写。
形式参数: 如果一个函数在运行的时候,存在的数据是要调用者确定的,那么这时候就应该定义形式参数。
return:把一个结果返回给调用者。
函数的作用:提高功能代码的复用性
函数的特点:
1. 函数的作用就是把一个功能代码给封装起来,已达到提高功能代码的复用性。
2.函数定义好之后是需要被调用才会执行的。其中main函数是由jvm调用的,不需要我们手动调用。
3.如果一个函数没有返回值返回给调用者,那么返回值类型必须是使用void表示。
如何定义一个函数:
1. 返回值类型。
2. 是否存在未知的参数(是否存在要由调用者确定的参数)。---->形式参数
class Demo1
{
public static void main(String[] args)
{
//int max = getMax(14,5); //调用了需求1的函数,括号内填写的是实际参数,实际参数由调用者确定
//System.out.println("最大值:"+ max);//输出需求1的结果 结果为14
getMax(3,7);//调用了需求2的函数
}
/*
//需求1: 定义一个函数比较两个int类型的数据大小,把最大值返回给调用者。
public static int getMax(int a, int b){ // 形式参数
int max = 0; //定义一个变量用于保存最大值的
if(a>b){
max = a;
}else{
max = b;
}
return max;//把结果返回给调用者
}
*/
//需求2:定义一个函数比较两个int类型的数据大小,不需要把最大值返回给调用者,直接打印即可。
public static void getMax(int a, int b){
int max = 0; //定义一个变量用于保存最大值的
if(a>b){
max = a;
}else{
max = b;
}
System.out.println("最大值:"+ max);
}
}
class Demo2
{
public static void main(String[] args) {
//String result = getGrade(91);//调用了需求1的函数,并把结果赋值给result
//System.out.println(result);//输出的结果为:A等级
print(7);//调用了需求2的函数
}
//需求1: 定义一个函数判断一个分数的等级,把分数的等级返回给调用者。
public static String getGrade(int score){
String grade = ""; //定义一个变量存储等级
if(score>=90&&score<=100){
grade = "A等级";
}else if(score>=80&&score<=89){
grade = "B等级";
}else if(score>=70&&score<=79){
grade = "C等级";
}else if(score>=60&&score<=69){
grade = "D等级";
}else if(score>=0&&score<=59){
grade = "E等级";
}else{
grade = "补考等级";
}
return grade;//把等级返回给调用者
}
//需求2: 定义一个函数打印一个乘法表,不需要返回任何数据。
public static void print(int row){
for(int i = 1 ; i<= row ; i++){
for (int j = 1 ;j<=i ;j++ ){
System.out.print(i+"*"+j+"="+i*j+"\t");
}
//换行
System.out.println();
}
}
}
注意: 如果一个函数的返回值类型是具体的数据类型,那么该函数必须要保证在任意情况下都保证有返回值。(除了返回值类型是void以外)
class Demo3{
public static void main(String[] args)
{
String result = getGrade(10);//调用函数
System.out.println("对应的等级是:"+ result );
}
public static String getGrade(int score){//未知的参数定义在形参中,由函数的调用者确定。
if(score>=90&&score<=100){
return "A等级";
}else if(score>=80&&score<=89){
return "B等级";
}else if(score>=70&&score<=79){
return "C等级";
}else if(score>=60&&score<=69){
return "D等级";
}else if(score>=0&&score<=59){
return "E等级";
}else{
//如果一个函数的返回值类型是具体的数据类型,那么该函数就必须要保证在任意情况下都保证有返回值。(除了返回值类型是void以外)
return "补考等级";
}
}
}
return 关键字的作用:
1. 返回数据给函数的调用者。
2. 函数一旦执行到了return关键字,那么该函数马上结束。 (能结束一个函数)
注意:如果一个函数的返回值类型是void,那么也可以出现return关键字,但是return关键字的后面不能有数据。
break关键字与return关键字的区别:
1.break关键字是结束一个循环。
2. return关键字是结束一个函数。
函数的重载:在一个类中出现两个或者两个以上的同名函数,这个称作为函数的重载。
函数重载的要求:
1. 函数名一致。
2. 形参列表不一致。(形式参数的个数或者是对应的数据类型不一致)
3. 与函数的返回值类型是无关的。
函数重载的作用: 同一个函数名可以出现不同的函数,以应对不同个数或者不同数据类型的参数。
class Demo4 {
public static void main(String[] args) {
add1(1,2);//调用了含有两个参数的函数
add(1,2.0);//调用了含有三个参数的函数
}
// 一下两个函数都是以函数重载在做加法运算。
public static double add(int a, int b){
System.out.println("两个参数的总和: "+ (a+b));
return 3.14;
}
public static void add(int a , int b , int c){
System.out.println("三个参数的总和: "+ (a+b+c));
}
}
数组
定义:数组是存储同一种数据类型数据的集合容器。
数组的定义格式:
数据类型[] 变量名 = new 数据类型[长度];
分析数组:
左边: int[] arr 声明了一个int类型的的数组变量,变量名为arr。
int : 表示该数组容器只能存储int类型的数据。
[] : 这是一个数组类型。
arr : 变量名。
右边:new int[50] 创建了一个长度为50的int类型数组对象。
new : 创建数组对象的关键字。
int:表示该数组对象只能存储int类型数据。
[]: 表示是数组类型。
50 : 该数组最多能存储50个数据。数组的容量。
数组的好处: 对分配到数组对象中的每一个数据都能够分配到一个索引值(编号、角标、下标),索引值的范围是从0开始,最大是: 长度-1。
局部变量: 如果一个变量是在一个函数(方法)的内部声明的,那么该变量就是一个局部变量。
成员变量: 成员变量就是定义在方法之外,类之内的.
class Demo5 {
public static void main(String[] args)
{
//定义一个数组
int[] arr = new int[4];
arr[0] = 10;
arr[1] = 30;
arr[2] = 50;
arr[3] = 90;
//System.out.println("数组的容量:"+ arr.length); //数组里有一个length 的属性,可以查看数组的容量。
//System.out.println("arr[2] = "+ arr[2]);//查看索引值为2的数组的值 结果为:50
//查看数组中的所有数据。
for(int index = 0 ; index<arr.length ; index++){
System.out.println(arr[index]);
}
}
}
数组的内存分析图:
数组中常见的问题:
1. NullPointerException 空指针异常
原因: 引用类型变量没有指向任何对象,而访问了对象的属性或者是调用了对象的方法。
2. ArrayIndexOutOfBoundsException 索引值越界。
原因:访问了不存在的索引值。
数组的初始方式:
动态初始化:数据类型[] 变量名 = new 数据类型[长度];
静态初始化:数据类型[] 变量名 = {元素1,元素2.....};
如果程序一开始你就已经确定了数据,那么这时候建议使用静态初始化。如果一开始数据还不太明确,这时候就建议使用动态初始化。
class Demo6{
public static void main(String[] args)
{
/*
//动态初始化
int[] arr = new int[10];
Scanner scanner = new Scanner(System.in);//创建扫描器对象
for(int i = 0 ; i< arr.length ; i++){
arr[i] = scanner.nextInt();//调用扫描器的nextInt()扫描数据,并把数据赋值于数组中
}
*/
//静态初始化
int[] arr = {10,20,30,40,50};
//查看数组的所有数据
for(int index = 0 ; index<arr.length ; index++){
System.out.print(arr[index]+",");
}
}
}
/*
需求: 定义一个函数接收一个int类型的数组对象,找出数组对象中的最大元素并返回给调用者。
*/
class Demo7 {
public static void main(String[] args)
{
int[] arr = {-12,-14,-5,-26,-4};//静态初始化
int max = getMax(arr);
System.out.println("最大值:"+ max); //结果为:-4
}
public static int getMax(int[] arr){
int max = arr[0]; //用于记录最大值
for(int i = 1 ; i < arr.length ; i++){
if(arr[i]>max){ //如果发现有元素比max大,那么max变量就记录该元素。
max = arr[i];
}
}
return max;//把max的值返回给调用者
}
}
View Code
数组常见的操作:
选择排序(直接排序):使用一个元素与其他的元素挨个比较一次,符合条件交换位置。
需求: 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。
class Demo8{
public static void main(String[] args)
{
int[] arr = {12,5,17,8,9}; //对于有5个元素的数组,只需要找出4个最大值就可以排序了。
selectSort(arr);
}
public static void selectSort(int[] arr){
//对以下注释的代码进行优化
for(int j = 0; j<arr.length-1; j++){ // 控制的是轮数。
for(int i = j+1 ; i<arr.length ; i++){ //控制的是每次找出的最大值
if(arr[i]>arr[j]){
//交换位置
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
/*
//把老大放在第一个位置
for(int i=1;i<arr.length;i++){
if(arr[i]>arr[0]){
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
}
}
//把老二放在第二个位置
for(int i = 2 ; i< arr.length ; i++){
if(arr[i]>arr[1]){
int temp = arr[i];
arr[i] = arr[1];
arr[1] = temp;
}
}
//把老三放在第三个位置
for(int i = 3 ; i< arr.length ; i++){
if(arr[i]>arr[2]){
int temp = arr[i];
arr[i] = arr[2];
arr[2] = temp;
}
}
//把老四放在第四个位置
for(int i = 4 ; i< arr.length ; i++){
if(arr[i]>arr[3]){
int temp = arr[i];
arr[i] = arr[3];
arr[3] = temp;
}
}
*/
//遍历数组,查看效果
System.out.print("目前的元素:");
for (int i = 0 ; i<arr.length ;i++){
System.out.print(arr[i]+",");
}
}
}
View Code
冒泡排序:冒泡排序的思想就是使用相邻的两个元素挨个比较一次,符合条件交换位置。
需求: 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。
class Demo9 {
public static void main(String[] args)
{
int[] arr = {12,8,17,5,9}; // 最大的索引值: 4 容量:5
bubbleSort(arr);
}
public static void bubbleSort(int[] arr){
//对以下注释的代码进行优化
for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
for(int i = 0 ; i<arr.length-1-j ; i++){ //控制找出一个最大值
//相邻的元素比较
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
/*
// 把最大值放在最后一个位置
for(int i = 0 ; i <arr.length-1-0 ; i++){
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
//把老二放在倒数第二个位置上。
for(int i = 0 ; i <arr.length-1-1 ; i++){
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
//把老三放在倒数第三个位置上。
for(int i = 0 ; i <arr.length-1-2 ; i++){
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
//把老四放在倒数第四个位置上。
for(int i = 0 ; i <arr.length-1-3 ; i++){
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
*/
//遍历数组,查看效果
System.out.print("目前的元素:");
for (int i = 0 ; i<arr.length; i++){
System.out.print(arr[i]+",");
}
}
}
View Code
二分查找法:定义三个变量分别记录要查找元素的范围最大索引值、中间索引值、最小索引值,每次都是使用中间索引值的元素与目标元素比较一次,如果不是我们所需要的元素,那么缩小查找的范围。
注意:使用二分查找法的前提必须是有序的数组。
需求:定义一个函数接收一个数组对象和一个要查找的目标元素,函数要返回该目标元素在数组中的索引值,如果目标元素不存在数组中,那么返回-1表示。
class Demo10 {
public static void main(String[] args)
{
int[] arr = {12,16,19,23,54};
//int index = searchEle(arr,23);//调用searchEle(),但是效率低
int index = halfSearch(arr,116);
System.out.println("元素所在的索引值是:"+ index);
}
public static int halfSearch(int[] arr, int target){
//定义三个变量分别记录最大、最小、中间的查找范围索引值
int max = arr.length-1;
int min = 0;
int mid = (max+min)/2;
while(true){
if(target>arr[mid]){
min = mid+1;
}else if(target<arr[mid]){
max = mid -1;
}else{
//找到了元素
return mid;
}
//没有找到的情况
if (max<min){
return -1;
}
//重新计算中间索引值
mid = (min+max)/2;
}
}
/*
public static int searchEle(int[] arr, int target){
for(int i = 0 ; i<arr.length ; i++){
if(arr[i]==target){
return i;
}
}
return -1;
}
*/
}
/*
需求: 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素。
例如:char[] arr = {'a','b','c','d','e'};翻转元素后的结果为e、d、c、b、a
*/
class Demo11{
public static void main(String[] args){
char[] arr = {'a','b','c','d','e'};
reverse(arr);
}
public static void reverse(char[] arr){
for(int startIndex = 0 ,endIndex = arr.length-1 ; startIndex<endIndex ; startIndex++,endIndex--){
char temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}
//遍历数组,查看效果
System.out.print("目前的元素:");
for (int i = 0 ; i<arr.length ;i++){
System.out.print(arr[i]+",");
}
}
}
二维数组:二维数组就是数组中的数组。
二维数组的定义格式:数据类型[][] 变量名 = new 数据类型[长度1][长度2];
二维数组的初始化方式:
动态初始化:数据类型[][] 变量名 = new 数据类型[长度1][长度2];
静态初始化:数据类型[][] 变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..};
二维数组的内存分析图:
数组的特点:
1. 数组只能存储同一种数据类型的数据。
2. 数组是会给存储到数组中的元素分配一个索引值的,索引值从0开始,最大的索引值是length-1;
3. 数组一旦初始化,长度固定。
4. 数组中的元素与元素之间的内存地址是连续的。
class Demo12{
public static void main(String[] args)
{
//定义了一个二维数组
int[][] arr = new int[3][4];
arr[1][1] = 100;
/*
System.out.println("二维数组的长度:"+ arr.length); //长度为3
System.out.println("二维数组的长度:"+ arr[1].length); //长度为4
*/
System.out.println("数组的元素:"+ arr[1][1]);结果为100
}
}