文章目录
调用方法的三种方式:
-
第一种:通过对象名.方法名进行调用,这是最普通的也是最常见的一种调用方式。
-
第二种:通过new关键字调用构造方法,这种是在实例化对象时使用的方式。
-
第三种:通过类名.方法名调用,当需要调用的那个方法为静态(有static的)方法时使用。
-
练习:定义一个方法,用于判断两个数字是否相同。
三要素:
返回值:boolean
方法名:isSame()
参数:int x, int y
public static boolean isSame(int x, int y){
return x == y;
}
return关键字
程序执行到方法里面的return语句时,方法就会返回,return下面的语句不会被执行。
例:
public class MethodTest{
public static void main(String[] args){
//不接收返回值也行,符合语法规则,编译可以通过。
sumInt(10,20);
//对于有返回值的方法,通常都会定义变量用来接收方法的返回值
int result = sumInt(10,20);
System.out.println("计算结果是:"+result);
}
public static int sumInt(int a,int b){
int c = a + b;
return c; //程序执行到此处sumInt方法执行结束。并将int类型的值c返回
}
public static int test1(){
return 1; //这行代码只要执行,整个方法就结束了。
//System.out.println("hello"); //这里的代码是无法执行的,编译报错。
}
public static void test2(){
return; //可以,return后面没有返回任何数据
}
/*
public static int test3(){
return; //错误
}
*/
}
如果方法有返回值,那么要在其方法里面设置返回值。
例:
public class MethodTest{
/*
* 编译阶段不会运行代码,编译器并不知道flag的值,它只知道flag要么是true,要么是false。
* 对于test1方法,编译器会考虑到当flag为false的时候,该方法就没有返回值了,所以在编译阶段会报错
*
*/
/*public static int test1() {
boolean flag = true;
if (flag) {
return 1;
}
}*/
//以下程序还是编译报错,因为编译器就认为以下的这个if语句的大括号当中的代码可能执行,也可能不执行。
/*
public static int test2(){
if(true){
return 1;
}
}
*/
//if结合else使用,这样要么执行if中的语句,要么执行else中的语句。
//此时编译器可以判定这个程序return 语句一定会执行的
public static int test3(boolean flag) {
/*
* 下面这种写法会报错,需要在else里面设置返回值
*/
/*if (flag) {
return 0;
} else {
System.out.println("1");
}*/
if (flag) {
return 0;
} else {
return 1;
}
}
//下面程序会报错吗?
//不会报错,因为这样编写可以保证一定会有一个return语句执行
public static int test4(){
boolean flag = false;
if(flag){
return 1;
}
return 0;
}
}
break,continue和return的区别
break; 和 continue; 这两个语句主要是用来控制循环的,跟方法没有关系。
return; 和以上的两个语句不是一个级别的,return;是用来终止当前方法的。
public class Test {
public static void main(String[] args){
test();
System.out.println("hello world!");
}
public static void test() {
for( int i = 0 ; i < 10 ; i ++ ){
if( i == 5 ){
//break;
//continue;
return; //终止当前方法的执行。(不是终止JVM的执行)
}
System.out.println("i = " + i);
}
}
}
方法重载(overload)
public class MethodTest{
public static void main(String[] args){
System.out.println(sum(10,20));
System.out.println(sum(1.0,2.0));
System.out.println(sum(10L,20L));
System.out.println(sum(1.0F,2.0F));
}
public static int sum(int a,int b){
return a + b;
}
public static double sum(double a,double b){
return a + b;
}
public static long sum(long a,long b){
return a + b;
}
public static float sum(float a,float b){
return a + b;
}
}
上面将之前的代码里面的4个方法名全部改成一样的了,这种情况叫做方法重载(overload)。
方法重载发生的条件
- 发生在同一个类中.
- 方法名相同
- 参数列表不同(类型,个数,顺序)
注意:
方法重载和返回值类型无关
方法重载和方法的修饰符列表无关。
//参数的类型不同,构成重载
public static void m1(int a){}
public static void m1(double a){}
//参数的个数不同,构成重载
public static void m2(int a,int b){}
public static void m2(int a){}
//参数的顺序不同,构成重载,不过开发中不这样使用
public static void m3(int a,double b){}
public static void m3(double a,int b){}
//以下两个m4方法并没有构成重载.
//两个方法完全一样,错误
//public static void m4(int a){}
//public static void m4(int b){}
/*
方法的重载和方法的返回值类型无关,不构成重载
public static void m5(){}
public static int m5(){
return 100;
}
*/
/*
方法的重载和方法的修饰符列表无关,不构成重载
static void m6(){}
public static void m6(){}
*/
数组
什么是数组?
- 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
- 数组里面既可以存储基本数据类型,也可以存储引用数据类型,但是只能存储同一种数据类型。
- 数组是一种简单的数据结构,线性的结构
- 数组一旦创建其长度是不可变的
- 数组是引用数据类型
数组的分类
一维数组
二维数组
三维数组
多维数组
如何定义数组?
//动态初始化
int[] array = new int[4];
array[0] = 5;
array[1] = 15;
array[2] = 25;
array[3] = 35;
//静态初始化
int[] array = new int[] {5, 15, 25, 35};
//打印长度
System.out.println(array.length);
课堂笔记
/*
* 变量: 存储一个数值
* 数组:存储多个数值
数组的特点:
1. 数组是一种引用数据类型
2. 数组当中的多个数据,类型必须统一
3. 数组的长度在程序运行期间不可改变
数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。
两种常见的初始化方式:
1. 动态初始化(指定长度)
2. 静态初始化(指定内容)
动态初始化数组的格式:
数据类型[] 数组名称 = new 数据类型[数组长度];
int[] arrayA = new int[300];
解析含义:
左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型
左侧的中括号:代表我是一个数组
左侧数组名称:给数组取一个名字
右侧的new:代表创建数组的动作
右侧数据类型:必须和左边的数据类型保持一致
右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字
*/
动态初始化(指定长度):在创建数组的时候,直接指定数组当中的数据元素个数。
静态初始化(指定内容):在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定。
静态初始化基本格式:
数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };
注意事项:
虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素具体内容,也可以自动推算出来长度。
//动态初始化拆分为步骤
int[] arrayC;
arrayC = new int[5];
//
// int[] arrayD;
// arrayD = { 10, 20, 30 }; 错误!静态初始化省略格式不能拆分为两个步骤
/*
直接打印数组名称,得到的是数组对应的:内存地址哈希值。
二进制:01
十进制:0123456789
16进制:0123456789abcdef
访问数组元素的格式:数组名称[索引值]
索引值:就是一个int数字,代表数组当中元素的编号。
【注意】索引值从0开始,一直到“数组的长度-1”为止。
*/
/*
使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下:
如果是整数类型,那么默认为0;
如果是浮点类型,那么默认为0.0;
如果是字符类型,那么默认为'\u0000';
如果是布尔类型,那么默认为false;
如果是引用类型,那么默认为null。
注意事项:
静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
*/
java中的内存划分:
只有一个数组的内存图:
有两个独立数组的内存图:
两个引用指向同一个数组的内存图:
数组的长度运行期间不可改变:
加强for循环 foreach
(1) foreach
用法: 主要是用来遍历数组和集合的;
缺点: 没有索引,凡是涉及有索引相关操作还是用普通for循环,
(2)语法结构
for(元素类型 e : 数组 ){
System.out.println(e);
}
遍历一个数组也可以使用我们之前学的for循环
这两种方式的打印结果一样。
课后作业
-
编写重载方法,分别实现输出字符串,字符串数组,整型数据和整形数组。
-
编写重载方法分别计算一个整数,一个浮点数的各位数字之和。
-
B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分?
-
定义一个数组,数组成员10个,找出数组中最大数连同下标一起输出
-
定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68},统计各成绩等级(90分以上为‘A’,8089分为‘B’,7079分为‘C’,60~69分为‘D’,60分以下为E)学生人数,并将其放入到数组count中,其中:count[0]存E级的人数,count[1]存D级的人数,……,count[4]存A级的人数。
-
先定义一个数组,再尝试把数组元素反转。
如:({5,8,3,4,1} -》 {1,4,3,8,5}) -
思考题:想一想为什么说数组的长度不可改变?
(提示:int[] a = new int[3]; a = new int[5],你觉得这样做是把长度为3的数组改变成长度为5的数组吗?)
- 编写重载方法,分别实现输出字符串,字符串数组,整型数据和整形数组。
package com.zcl.homework;
public class D04_1 {
public static void main(String[] args) {
String[] s = new String[] { "这", "是", "数组" };
int[] i = new int[] { 89, 92, 94, 88, 94, 93, 98, 96, 91, 97 };
String a = "这是字符串";
Output(a);
Output(s);
Output(5);
Output(i);
}
public static void Output(String s) {
System.out.println(s);
}
public static void Output(String[] s) {
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]);
}
}
public static void Output(int s) {
System.out.println(s);
}
public static void Output(int[] s) {
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+" ");
}
}
}
- 编写重载方法分别计算一个整数,一个浮点数的各位数字之和。
package com.zcl.homework;
public class D04_2 {
public static void main(String[] args) {
add(468);
add(468.56);
}
public static void add(int num) {
int count = 0;
while (num != 0) {
count += num % 10;
num = num / 10;
}
System.out.println("整数各位数之和:"+count);
}
public static void add(double num) {
int count = 0;
//写一个循环,每次乘10,直到成为整数
while (num != (int)num) {
num *= 10;
}
while (num != 0) {
count += num % 10;
num = num / 10;
}
System.out.println("浮点数各位数之和:"+count);
}
}
- B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分?
package com.zcl.homework;
public class D04_3 {
public static void main(String[] args) {
int[] i = new int[] { 8, 9, 9, 8, 7, 9, 8, 6, 5, 7 };
average(i);
}
public static void average(int[] array) {
int min = array[0];
int max = array[0];
for (int i = 0;i < array.length;i++) {
min = array[i] > min ? min : array[i];
}
for (int i = 0; i < array.length;i++) {
max = array[i] < max ? max : array[i];
}
int sum = 0;
for (int i = 0;i <= 9;i++) {
sum += array[i];
}
double ave = (double)(sum-min-max)/(array.length-2);
System.out.println(max);
System.out.println(min);
System.out.println(ave);
}
}
- 定义一个数组,数组成员10个,找出数组中最大数连同下标一起输出
package com.zcl.homework;
public class D04_4 {
public static void main(String[] args) {
int[] i = new int[] { 89, 92, 94, 88, 94, 93, 98, 96, 91, 97 };
Max(i);
}
public static void Max(int[] array) {
int max = array[0];
int index = 0;
for (int i = 0; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
index = i;
}
//max = array[i] < max ? max : array[i];
}
System.out.println("最大数为:" + max + "下标为:" + index);
}
}
- 定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68},统计各成绩等级(90分以上为‘A’,8089分为‘B’,7079分为‘C’,60~69分为‘D’,60分以下为E)学生人数,并将其放入到数组count中,其中:count[0]存E级的人数,count[1]存D级的人数,……,count[4]存A级的人数。
package com.zcl.homework;
public class D04_5 {
public static void main(String[] args) {
int[] array = new int[] { 72, 89, 65, 58, 87, 91, 53, 82, 71, 93, 76, 68 };
Count(array);
}
public static void Count(int[] array) {
int[] arr = new int[5];
for (int i = 0; i < array.length; i++) {
if (array[i] >= 90) {
arr[4]++;
} else if (array[i] < 90 && array[i] >= 80) {
arr[3]++;
} else if (array[i] < 80 && array[i] >= 70) {
arr[2]++;
} else if (array[i] < 70 && array[i] >= 60) {
arr[1]++;
} else {
arr[0]++;
}
}
System.out.println("数组count为[" + arr[0] + "," + arr[1] + "," + arr[2] + "," + arr[3] + "," + arr[4] + "]");
}
}
- 先定义一个数组,再尝试把数组元素反转。
如:({5,8,3,4,1} -》 {1,4,3,8,5})
package com.zcl.homework;
public class D04_6 {
public static void main(String[] args) {
int[] a = new int[] { 5, 8, 3, 4, 1 };
reversal(a);
}
public static void reversal(int[] arr) {
int min = 0;
int max = arr.length-1;
while (min < max) {
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
min++;
max--;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
- 思考题:想一想为什么说数组的长度不可改变?
(提示:int[] a = new int[3]; a = new int[5],你觉得这样做是把长度为3的数组改变成长度为5的数组吗?)
不可改变,每次初始化一个数组都是在堆里申请一个独立的空间,无法更改数组的长度,同一个数组被再次初始化后也会重新申请一个独立的空间,原来的不会改变,也不会再用