4.1Java基础语法（方法、一维数组）
一、方法
A:定义：
方法就是完成特定功能的代码块
在java中,我们把函数叫方法,其他语言:javascript方法称之为函数: function add()
举例:键盘录入的这个类Scanner
Scanner sc = new Scanner(System.in) ;
sc.nextInt() ;
B：
1）定义方法的格式:
权限修饰符 返回值类型 方法名(数据类型1参数名1,数据类型2参数名2....){//小括号里面:形式参数列表
return结果;
}
2）详细解释:
a.权限修饰符:public + static(静态修饰) :暂时先这样写权限修饰符
b.返回类型:最终计算的结果的数据类型: (结果是什么数据类型,就用该类型去接收结果)
c.方法名:就是给这个功能的代码块起名字:命名规则:一个单词字母全小写;多个单词:第一个单词小写,第二个单词开始首字母大写
d.形式参数列表:形式参数的数据类型(四类八种)形式参数名(变量名)
return:在方法中出线,表示带回一个结果
3)如何调用:针对有返回值类型的方法的调用:
1)单独调用,没有任何意义,没有输出
2)输出调用,虽然可以得到一个结果,但是不够好,不能对结果进行下一步操作!
3)赋值调用,可以对结果下一步操作!(有返回值类型的方法调用)
方法调用图解：
4）如何写一个方法呢?两个明确
a.返回值类型 明确功能结果的数据类型
b.参数列表 明确有几个参数，以及参数的类型
C：定义方法的注意事项:
1)方法和方法是平级关系,不能将一个方法写到main主程序入口里面
2)方法不调用不执行
3)在main方中去调用其他方法的时候,实际参数不用再给数据类型了,否则报错
4)定义方法的时候:形式参数必须带上数据类型,否则报错
5)方法定义完毕:(有返回值类型的方法:返回具体的结果:否则不写return:编译不通过)
6)定义方法:有左大括号的地方不能有分号,有分号的地方不能有做大括号!
5）没有返回值类型的方法:void的调用
没有具体的返回值,java就提供了一个关键字:void
举例：
package方法_01;
/*
*在控制台输出:
******
******
******
******
*
*
*单独调用
*输出调用
*赋值调用
* */
public class FunctionDemo3 {
public static void main(String[] args) {
//使用for嵌套
//4行5列
for(int x = 0 ; x <4; x ++){
for(int y = 0 ; y < 5; y++){
System.out.print("*");
}
System.out.println();
}
System.out.println("-------------");
//6行7列
for(int x = 0 ; x <6; x ++){
for(int y = 0 ; y < 7; y++){
System.out.print("*");
}
System.out.println();
}
System.out.println("-----------------");
//8行9列....
//需求不断变化
//封装成独立的代码块
//调用方法:
//输出调用:错误的:void的返回值类型不能这样使用
//System.out.println(printXing(6, 7));
//赋值调用
//Void v = printXing(6,7) ;//错误的
//没有具体的返回值类型void
//单独调用
printXing(8, 9) ;
System.out.println("-------------------");
printXing(6, 7) ;
System.out.println("-------------------");
printXing(5, 6) ;
}
/*
*定义打印*形的方法
*
*两个明确:
*方法定义格式:权限修饰符 静态修饰符 返回值类型 方法名(形式参数列表...){return}
*明确返回值类型:由于将*形输出在控制:打印在控制台,没有具体的返回值,java就提供了一个关键字:void
*
*针对没有返回值类型的方法,没有return,因为直接在控制台输出
*
*
*明确参数类型:2个参数,都是int
* */
public static void printXing(int m,int n){
//直接使用for循环嵌套
for(int x = 0 ; x < m; x++){
for(int y = 0 ; y < n; y++){
System.out.print("*");
}
System.out.println();
}
}
}
6）方法重载(Overload)
a.概述:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
b.特点:与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
举例：
package方法_01;
/*
*需求:求数据的和:
*
*根据不同需求,分别写了三个之和,四个数据之和,
*但是他们的方法名不一样,给方法起名字:见名知意.
* java为了能够起名字见名知意,就提供了一个专业名词:方法重载!允许在同一个类中,出现相同的方法名
*
*面向对象:方法重写:Override(后面讲)
* */
public class FunctionDemo4 {
public static void main(String[] args) {
//jvm根据不同的方法区调用不同的参数
//输出调用
System.out.println(sum(30,40));
System.out.println(sum(30,40,50));
System.out.println(sum(30,40,50,60));
System.out.println(sum(12.34F,3.14F));
}
// 求两个数据之和的方法
public static int sum(int a,int b){
return a + b;
}
// 求三个数据之和:
public static int sum(int a,int b,int c){
return a+b+c;
}
// 求四个数据之和:
public static int sum(int a,int b, int c, int d){
return a+ b+ c+d ;
}
public static float sum(float a,float b){
return a + b ;
}
}
7）练习：
1.键盘录入两个数据,求两个数据中的最大值(使用方法写一个求最大值的功能)
package方法_01;
import java.util.Scanner;
public class FunctionTest {
public static void main(String[] args){
//1)创建键盘录入对象
Scanner sc = new Scanner(System.in);
//2)录入并接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt();
System.out.println("请输入第二个数据:");
int b = sc.nextInt() ;
//写一个求两个数据最大值的功能代码块
int max = getMax(a, b) ;
System.out.println("最大值是:" +max);
}
/**
*两个明确:
* a:明确返回值类型:int类型
* b:明确参数类型:int ,几个参数:2个参数
* */
public static int getMax(int a,int b){
////可以使用if语句
//if(a > b){
//return a ;
//}else {
//return b ;
//}
//使用三元运算符改进
//int c = (a>b) ? a: b ;
//return c ;
//c代表(a>b) ? a: b ;
//改进
return (a>b) ? a: b ;
}
}
2.键盘录入两个数据,求两个数据是否相等.(写一个功能)
package方法_01;
import java.util.Scanner;
/*
*分析:
*最终的结果是boolean
* */
public class FunctionTest2 {
public static void main(String[] args){
//1)创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//2)录入并接收数据
System.out.println("请输入第一个数据:");
int firstNumber = sc.nextInt();
System.out.println("请输入第二个数据:");
int secondNumber = sc.nextInt() ;
//调用比较的方法
boolean flag = compare(firstNumber,secondNumber) ;
System.out.println("flag:" +flag);
}
/*
*两个明确:
*明确返回值类型:boolean
* 明确参数类型:int类型, 2个参数
* */
public static boolean compare(int a,int b){
//使用if语句
//if(a==b){
//return true;
//}else{
//return false;
//}
//三元运算符改进
//boolean flag = (a==b) ? true : false ;
//return flag ;
//继续改进
//return (a==b) ? true : false ;
//最终版
return a==b ;
}
}
3.键盘录入三个数据，返回三个数中的最大值(功能实现)
package方法_01;
import java.util.Scanner;
public class FunctionTest3 {
public static void main(String[] args) {
//1):创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//2)录入并接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt() ;
System.out.println("请输入第二个数据:");
int b = sc.nextInt() ;
System.out.println("请输入第三个数据:");
int c = sc.nextInt() ;
//调用方法:
int max = getMax(a, b, c) ;
System.out.println("max:" +max);
}
/*
*两个明确:
*明确返回值类型:int
*明确参数个数以及参数类型:3个参数,int类型
* */
public static int getMax(int a,int b,int c){//形式参数
//if语句的嵌套
//if(a > b){
//if(a > c){
//return a ;
//}else {
//return c ;
//}
//}else{
//if(b > c){
//return b ;
//}else {
//return c ;
//}
//}
//使用三元运算符:if和三元结合使用
//if(a >b){
//return (a>c) ? a: c ;
//}else{
//return (b >c)? b: c;
//}
//三元运算符一步走
//return (a>b) ? (a>c? a: c) : (b > c? b : c) ;
//不建议使用这种方式:阅读性差
//开发常使用的中间第三方变量
//定义变量
int temp = (a > b) ? a : b ;
int max = (temp > c)? temp : c ;
return max ;
}
}
4.键盘录入行数和列数,输出对应 的*形(通过方法去实现)
package方法_01;
import java.util.Scanner;
public class FunctionTest4 {
public static void main(String[] args) {
//1)创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//2)录入并且接受数据
System.out.println("请输入行数的值:");
int m = sc.nextInt() ;
System.out.println("请输入列数的值:");
int n = sc.nextInt();
//调用方法
printXingXing(m, n) ;
}
/*
*两个明确:
*明确返回值类型:void
*明确参数类型:int类型,2个参数
* */
public static void printXingXing(int m,int n){
for(int x = 0 ; x < m; x ++){
for(int y = 0 ; y
System.out.print("*");
}
System.out.println();
}
}
}
5.键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
package方法_01;
import java.util.Scanner;
public class FunctionTest5 {
public static void main(String[] args) {
//1)创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//2)录入并接收数据
System.out.println("请您输入n的值(1~9):");
int n = sc.nextInt() ;
//调用方法
printNN(n) ;
}
/*
*两个明确:
*明确返回值类型:void
*明确参数类型:1个参数,int类型
* */
public static void printNN(int n){
//nn乘法表
for(int x = 1 ;x <= n ; x ++){
for(int y = 1 ; y<=x ;y++){
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
6.求两数据是否相等,参数分别是：
两个byte类型,两个short类型,两个int类型,两个long类型
package方法_01;
public class FunctionTest6 {
public static void main(String[] args) {
//定义两个变量
byte a = 3 ;
byte b = 5 ;
boolean flag = compare(a, b) ;
System.out.println(flag);
//两个short类型
short s1 = 5 ;
short s2 = 5 ;
boolean flag2 = compare(s1, s2) ;
System.out.println(flag2);
//两个int类型
int m=7;
int n=10;
boolean flag3 = compare(m, n) ;
System.out.println(flag3);
//两个long类型
long x=4L;
long y=4;
boolean flag4 = compare(x, y) ;
System.out.println(flag4);
}
/*
*测试byte
*明确返回值类型:boolean
*明确参数类型:byte ,2个参数
* */
public static boolean compare(byte a,byte b){
return a==b ;
}
// short类型
public static boolean compare(short s1,short s2){
return s1== s2 ;
}
//int
public static boolean compare(int m,int n){
return m==n;
}
//long
public static boolean compare(long x,long y){
return x==y;
}
}
二、数组
A:1）概念:
用来存储同一种数据类型的容器;
举例:水杯中的水
2）定义格式:
第一种：数据类型[]数组名;
第二种：数据类型数组名[] ;
举例:int[] a ;---->定义了一个int类型的数组变量a(推荐使用第一个)
int a[] ;---->定义了一个int类型的a数组变量
效果一样,只是读法上不一样;推荐使用第一种
3）数组如何进行初始化?
什么叫初始化:其实就是给数组中的元素赋值!
数组的初始化分为两种:
a.动态初始化:指定数组的长度,它的元素值由系统默认分配
b.静态初始化:指定的数组的具体元素,数组长度由系统默认分配
B:数组的动态初始化:
数据类型[]数组名= new 数据类型[指定数组长度] ;
数据类型数组名[] = new数据类型[指定数组长度] ;
举例:int[] arr = new int[3] ;
int arr[] = new int[3] ;
1）详细解释：
public class ArrayDemo {
public static void main(String[] args){
//定义数组
//int[] a ;
//该变量可能没有初始化
//System.out.println(a);
int[] arr = new int[3] ; //引用类型:动态初始化:索引元素值由系统分配
/*
* =号左边:
* int:表示的该数组中的元素都是int类型
* []:表示一维数组(一般情况:没有告诉使用一维数组还是二维数组:默认使用一维数组)
* arr :表示数组名称
* =号右边
* new :表示在堆内存中开辟空间:创建对象
* int:表示数组的数据类型是int类型
* 3:表示数组的长度为3,里面有3个元素
*
* */
System.out.println(arr);//[I@778b3fee :@标记:地址值
/*
*如何获取数组中的元素值:
*数组名称[索引] ;
*索引:其实就是数组从左边第一个开始编号,从0开始
* arr[0]
* arr[1]
* arr[2]
*
*数组的最大索引:数组的长度-1;
* */
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
【Java中的内存分配】
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈：存储局部变量
堆：存储new出来的东西
方法区：(面向对象部分讲)
本地方法区：(和系统相关)
寄存器：(给CPU使用)
如下图解：
2）由程序理解java的内存分配：
a.定义一个数组,分别输出该数组名称以及数组的元素,
给数组中的元素进行赋值,再次输出数组名称以及数组的元素
package数组;
public class ArrayDemo{
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[3] ;
System.out.println(arr);//[I@538edf3c
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0
//给元素赋值
arr[0] = 100 ;
arr[2] = 200 ;
System.out.println(arr);//[I@39813c12
System.out.println(arr[0]);//100
System.out.println(arr[1]);//0
System.out.println(arr[2]);//200
}
}
图解如下：
b.定义两个数组,分别输出两个数组的名称以及元素
给两个数组中的元素赋值,再次输出数组名称以及元素
package数组;
public class ArrayDemo{
public static void main(String[] args) {
//定义第一个数组
int[] arr1 = new int[2] ;
//定义第二个数组
int[] arr2 = new int[3] ;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
//赋值
arr1[0] = 20 ;
arr2[1] = 40;
arr2[0] = 60 ;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
图解如下：
c.定义三个数组:
将第一个数组的名称和元素输出
将第二个数组的名称和元素输出
定义第三个数组:将第一个数组的名称赋值给第三个数组名称
通过第三数组的名称去给第一个数组的元素赋值
package数组;
public class ArrayDemo{
public static void main(String[] args) {
int[] arr1 = new int[3] ;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
int[] arr2 = new int[2] ;
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
//给元素赋值
arr1[0] = 100 ;
arr1[2] = 50 ;
arr2[0] = 30 ;
//定义第三个数组
int[] arr3 = arr1 ;
arr3[0] = 200 ;
arr3[2] = 70;
System.out.println(arr3);
System.out.println(arr1[0]);//200
System.out.println(arr1[1]);//0
System.out.println(arr1[2]);//70
}
}
图解如下：
C:数组的静态初始化:
1）格式:
数据类型[]数组名= new 数据类型[]{元素1,元素2,元素3...} ;
简化版格式:(推荐使用)
数据类型[]数组名= {元素1,元素2,元素3.....} ;
举例:
int[] arr = new int[]{1,2,3} ;
简化版:
int[] arr = {1,2,3} ;
2）注释事项:
不能同时给数组进行统动态初始化以及静态初始化
int[] arr = new int[3]{1,2,3} ; //错误的
数组的静态初始化图解：
【在java中经常会出现的两种异常】
运行时期异常:Runtime Exception
java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常!
出现这个异常的原因:访问了数组中不存在的索引
运行时期的异常:
java.lang.NullPointerException:空指针异常:
出现这个异常的原因:数组的对象为空,都不执行内存地址值,还要输出元素.
举例：
package数组;
public class ArrayDemo {
public static void main(String[] args) {
//定义数组并且静态初始化
int[] arr = {1,2,3} ;//index = 0,1,2
//System.out.println(arr[3]);
arr = null ;//数组引用类型:引用类型的默认值位null:对象是空的
//空指针异常的解决办法:非空判断
if(arr != null){
System.out.println(arr[0]);
}
}
}
3）练习：
a.数组的遍历:
获取数组的元素分别打印出来
package数组;
public class ArrayTest {
public static void main(String[] args) {
//定义一个数组并且静态初始化
int[] arr = {11,22,33,44,55} ;
//如何获取数组中的元素
//通过数组名称[索引值]获取
//System.out.println(arr[0]);
//System.out.println(arr[1]);
//System.out.println(arr[2]);
//System.out.println(arr[3]);
//System.out.println(arr[4]);
//上述代码重复高,使用for循环:arr数组名称不变
//x = 0,1,2,3,4
//for(int x= 0 ;x <5 ; x ++){
//System.out.println(arr[x]);
//}
//
//System.out.println("-----------------");
//定义另一个数组
//int[] arr2 = {1,2,35,60,90,10,45,65,4,7,19,22,45,67} ;
/*
*针对这种情况:数组给我们提供了一个属性:length
* */
//System.out.println(arr.length);
//System.out.println(arr2.length);
//改进上面的for循环代码
//for(int x = 0 ; x < arr.length ; x++){
//System.out.println(arr[x]);
//}
//如果在遍历多个数组,都写在main方法中代码比较臃肿,所以将遍历的方法封装成一个独立的功能代码块
//单独调用
printArray(arr) ;
System.out.println("----------------");
printArray2(arr) ;
}
/*
*两个明确:
*明确返回值类型:void
*参数类型:int[] 类型arr
* */
public static void printArray(int[] arr){
for(int x = 0 ; x < arr.length ; x++){
System.out.println(arr[x]);
}
}
////[11,22,33,44,55]
//改进代码
public static void printArray2(int[] arr){
System.out.print("[");
//开始遍历数组中的元素
for(int x = 0 ; x < arr.length ; x++){
//判断是否为最后一个索引对应的元素
if(x == arr.length-1){//索引值:最大索引=数组长度-1;
System.out.println(arr[x] +"]");
}else{
//不是最后一个元素
System.out.print(arr[x]+", ");
}
}
}
}
b.获取数组中最大值或者最小值
package数组;
/*
*分析:
*1)定义一个数组,静态初始化
*2)在数组中去一个元素作为参照物,(一般情况取的是第一个元素)认为它就是最大值max
*3)再遍历其元素:
*判断:如果其他元素都大于max,那么该元素就是最大值
*4)输出最大值
* */
public class ArrayTest {
public static void main(String[] args) {
//1)定义数组,静态初始化
int[] arr = {67,98,10,50,45} ;
////2)将该数组中的第一个元素作为参照物,赋值max变量
//int max = arr[0] ;
//
////3)遍历其他元素,得到每一个元素和参照物进行比较,大的留下了
//for(int x = 1 ; x < arr.length ; x++){
////判断
//if(arr[x] > max){
//max = arr[x] ;
//}
//}
//
////输出结果
//System.out.println("该数组中的最大值是:" +max);
/*
*写一个求数组最大值的功能
* */
//调用
int max = getMax(arr) ;
System.out.println("max:"+max);
}
/*
*两个明确:
*明确返回值类型:int
*明确参数类型: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 ;
}
}
c.数组与元素的逆序
package数组;
/*
*思路: 1)定义数组,静态初始化
*2)将0索引的元素和..arr.length-1-0的元素交换
*将1索引的元素和arr.length--1-的元素交换
*....
*做到索引是arr.length/2
* */
public class ArrayTest{
public static void main(String[] args) {
//1)定义数组,静态初始化
int[] arr = {12,76,50,98,25} ;
System.out.println("逆序前:");
printArray(arr);
System.out.println("逆袭后:");
//reverse(arr) ;
reverse2(arr) ;
printArray(arr);
}
/*
*逆序的方法:
*明确返回值类型:void
*参数类型int[]
* */
public static void reverse(int[] arr){
//第一次交换,采用中间变量
//int temp = arr[0] ;
//arr[0] = arr[arr.length-1-0];
//arr[arr.length-1-0] = temp ;
//
////第二次交换
//temp = arr[1] ;
//arr[1] = arr[arr.length-1-1] ;
//arr[arr.length-1-1] = temp ;
//重复读高,采用循环
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 ;
}
}
//采用方式2:
public static void reverse2(int[] arr){
for(int start = 0 ,end = arr.length-1; start
//定义中间变量
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
//数组的遍历
public static void printArray(int[] arr){
System.out.print("[");
for(int x = 0 ; x < arr.length; x++){
//判断
if(x==arr.length-1){
System.out.println(arr[x] +"]");
}else{
System.out.print(arr[x]+", ");
}
}
}
}
d.数组元素查表法:
需求:键盘录入一个数据,查询对应的星期;
package数组;
import java.util.Scanner;
/*
*定义字符串数组
*String[] strArray = {"星期一","星期二"....} ;
* */
public class ArrayTest{
public static void main(String[] args) {
//定义一个字符数组
String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收数据
System.out.println("请输入一个数据(0~6):");
int index = sc.nextInt() ;
System.out.println("你要查找是: " + strArray[index]);
}