(1)方法：就是完成特定功能的代码块。
注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
main方法是被虚拟机调用的
(2)格式：修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}
修饰符：目前就用 public static。后面再详细讲解其他修饰符
返回值类型：就是功能结果的数据类型
方法名：就是起了一个名字，方便我们调用该方法。
参数类型：就是参数的数据类型
参数名：就是变量
参数分类：
实参：实际参与运算的数据
形参：方法上定义的，用于接收实际参数的变量
方法体语句：就是完成功能的代码块
return：结束方法
返回值：就是功能的结果，由return带给调用者。
(3)两个明确：
返回值类型：结果的数据类型
参数列表：参数的个数及对应的数据类型
(4)方法调用
A:有明确返回值的方法
a:单独调用，没有意义
b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。
c:赋值调用，推荐方案
B:void类型修饰的方法
a:单独调用
(5)案例：
A:求和方案
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(sum(3,4));
}
public static int sum(int a,int b){
return a+b;
}
} 
B:获取两个数中的较大值
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("两个数中的较大值："+max(3,4));
}
public static int max(int a,int b){
if(a>b)
return a;
else
return b;
}
}C:比较两个数据是否相同
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("两个数是否相等："+compare(3,4));
}
public static String compare(int a,int b){
if(a==b)
return "是";
else
return "否";
}
}D:获取三个数中的最大值
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("三个数中的最大值："+compare(3,4,5));
}
public static int compare(int a,int b,int c){
if(a>b){
if(a>c)
return a;
else
return c;
}
else{
if(b>c)
return b;
else
return c;
}
}
}
E:输出m行n列的星形
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
System.out.println("请输入需要显示多少行多少列的*");
int row = scan.nextInt();
int col = scan.nextInt();
see(row,col);
}
public static void see(int row,int col){
for(int i=1;i<=row;i++){
for(int j=1;j<=col;j++){
System.out.print("*");
}
System.out.println("");
}
}
}F:输出nn乘法表
上一篇博文中有，将其封装到方法中调用即可
(6)方法的注意事项A:方法不调用不执行
B:方法之间是平级关系，不能嵌套定义
C:方法定义的时候，参数是用，隔开的
D:方法在调用的时候，不用在传递数据类型
E:如果方法有明确的返回值类型，就必须有return语句返回。
在同一个类中，方法名相同，参数列表不同。与返回值无关。调用时，虚拟机通过参数列表的不同来区分同名方法
参数列表不同：
参数的个数不同。
参数的对应的数据类型不同。
(8)方法重载案例
不同的类型的多个同名方法的比较。
重载练习比较数据是否相等
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
byte b1=3;
byte b2=4;
System.out.println(compare(b1,b2));
short s1=3;
short s2=4;
System.out.println(compare(s1,s2));
int i1=3;
int i2=4;
System.out.println(compare(i1,i2));
long l1=3L;
long l2=4L;
System.out.println(compare(l1,l2));
}
//byte类型
public static boolean compare(byte a,byte b){
System.out.println("byte");
return a==b;
}
//short类型
public static boolean compare(short a,short b){
System.out.println("short");
return a==b;
}
//in类型
public static boolean compare(int a,int b){
System.out.println("int");
return a==b;
}
//long类型
public static boolean compare(long a,long b){
System.out.println("long");
return a==b;
}
}(1)数组：存储同一种数据类型的多个元素的容器（集合）。
可以存储基本类型，也可以存储引用类型
(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。编号的专业叫法：索引
通过数组访问数据的格式：数组名[索引]
(3)定义格式A:数据类型[] 数组名;
B:数据类型 数组名[];
推荐是用A方式。
(4)数组的初始化（使用变量必须初始化）
数组初始化：为数组中的数组元素分配内存空间（new），并为每个数组元素赋值
A:动态初始化只给长度，系统给出默认值
举例：int[] arr = new int[3]; //定义了一个int型的数组，可以存储3个int型的值
System.out.println(arr);//输出的是地址值
B:静态初始化给出值，系统决定长度
举例：int[] arr = new int[]{1,2,3};
简化版：int[] arr = {1,2,3};
不要同时静态和动态进行
如下格式：int [] arr = new int[3]{1,2,3}; //错误
(5)Java的内存分配A:栈 存储局部变量（栈内存中的数据用完就释放掉）
B:堆 存储所有new出来的（每一个new出来的都有地址值）
C:方法区(面向对象部分详细讲解)
D:本地方法区(系统相关)
E:寄存器(CPU使用)
注意：
a:局部变量 在方法定义中或者方法声明上定义的变量。
b:栈内存和堆内存的区别
栈：数据使用完毕，就消失。
堆：每一个new出来的东西都有地址
每一个变量都有默认值
byte,short,int,long 0
float,double 0.0
char '\u0000'（空字符）
boolean false
引用类型 null（引用类型的常量：空常量）
数据使用完毕后，但是并没有立即回收，在垃圾回收器空闲的时候回收。
栈内存的两个引用指向同一个堆内存空间，无论是他们谁的操作，都是针对同一个地方
ArrayIndexOutOfBoundsException:数组索引越界异常
NullPointerException：空指针异常
数组已经不再指向堆内存了
(6)数组内存图A:一个数组
B:二个数组
C:三个数组(两个栈变量指向同一个堆内存)
(7)数组的常见操作
A:遍历
方式1：
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}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.println(arr[x]+", ");
}
}
}最大值：
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;
}public static int getMin(int[] arr) {
int min = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] < min) {
min = arr[x];
}
}
return min;
}方式1：
public static void reverse(int[] arr) {
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;
}
}public static void reverse(int[] arr) {
for(int start=0,end=arr.length-1; start<=end; start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}public static String getString(String[] strArray,int index) {
return strArray[index];
}方式1：
public static int getIndex(int[] arr,int value) {
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
return x;
}
}
return -1;
}方式2：
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}(1)元素是一维数组的数组。
(2)格式：
A:数据类型[][] 数组名 = new 数据类型[m][n];
或：数据类型 []数组名[] = new 数据类型 [m][n];
B:数据类型[][] 数组名 = new 数据类型[m][];
表示这个二维数组有多少个一维数组
列数没有给出，可以动态的给，这一次是一个变化的列数
C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
D:数据类型[][] 数组名 = {{...},{...},{...}};
A:二维数组的遍历
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int [][]arr = {{1,2,3},{4,5,6},{7,8,9}};
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]);
}
}
}
}B:二维数组的求和
import java.util.Scanner;
/*
公司年销售额求和
某公司按照季度和月份统计的数据如下，单位（万元）
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
*/
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int [][]arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum = 0;
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
sum +=arr[i][j];
}
}
System.out.println("元素累加结果为："+sum+"万元");
}
}C:杨辉三角形
import java.util.Scanner;
/*
打印杨辉三角（行数可以键盘录入）
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
步骤：
首先定义一个二维数组，行数如果是n，我们把列数也先定义为n
这个n的数据来自键盘录入
给这个二维数组任何一行和最后一列赋值为1
按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和
遍历这个二维数组
*/
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
System.out.println("请输入一个数据");
int row = scan.nextInt();
int [][] arr = new int [row][row];
for(int i = 0;i<arr.length;i++){
arr[i][0] = 1;
arr[i][i] = 1;
}
for(int i = 2;i<arr.length;i++){
for(int j = 1;j<=i-1;j++){
arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
}
}
for(int i=0;i<arr.length;i++){
for(int j=0;j<=i;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println("");
}
}
}
两个思考题
(1)Java中的参数传递问题
Java中只有值传递。基本数据传递的是数据值，引用类型传递的是地址值
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字
最后将第一位和最后一位数字交换，请任意给定一个小于8位的整数，然后，把加密后的结果在控制台打印出来
import java.util.Scanner;
/*
数据是小于8位的整数
定义一个int类型的数据
int number = 123456;
加密规则：
首先将数据倒序 654321
然后将每位数字都加上5，再用和除以10的余数代替该数字 109876
最后将第一位和最后一位数字交换 609871
*/
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
System.out.println("请输入一个8位的整数");
int number = scan.nextInt();
int [] arr=new int[8];
int index=0;
while(number>0){
arr[index] = number%10;
index++;
number/=10;
}
for(int i=0;i<index;i++){
arr[i]=(arr[i]+5)%10;
}
int temp = arr[0];
arr[0]=arr[index-1];
arr[index-1]=temp;
for(int i=0;i<index;i++){
System.out.print(arr[i]);
}
}
}
扫一扫
4915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
