▷ 静态初始化数组
数组:
就是一个容器,用来存储一批 同种类型
的数据
静态化数组:
就是预先填入数组的元素,知道数组有哪些值
格式:
定义 数据类型[] 数组名
也可以写成 数据类型 数组名[]
注意:
什么类型的数组只能存放什么类型的数据
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int [ ] arr = {
1 , 20 , 32 , 41 , 54 } ;
String [ ] names = {
"飞兔小哥" , "博客专家" , "天猫精灵测评官" } ;
}
}
▷ 静态初始化数组定义的三种方式
方式一: 数组类型[] 数组名 = new 数组类型{元素一, 元素二, 元素三}
方式二: 数组类型[] 数组名 = {元素一, 元素二, 元素三}
方式三: 数组类型 数组名[] = {元素一, 元素二, 元素三}
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
String [ ] names = new String [ ] {
"飞兔小哥" , "博客专家" , "天猫精灵测评官" } ;
int [ ] age = {
20 , 25 , 32 } ;
double height[ ] = new double [ ] {
172.4 , 168.9 , 184.9 } ;
}
}
▷ 数组的访问
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
String [ ] names = new String [ ] {
"飞兔小哥" , "博客专家" , "天猫精灵测评官" } ;
System . out. println ( names[ 0 ] ) ;
System . out. println ( names[ 1 ] ) ;
System . out. println ( names[ 2 ] ) ;
}
}
▷ 数组的长度
格式: 数组名.length
,通过该程序可以获取数组中的元素个数
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
String [ ] names = new String [ ] {
"飞兔小哥" , "博客专家" , "天猫精灵测评官" } ;
System . out. println ( names. length) ;
}
}
▷ 数组存储原理
数组变量中存储的是数组在 内存中的地址
,而数组是一种引用类型的数据,变量的地址指向了最终的数据
就好像数组名是门牌号,只有通过门牌号才能找到家一样
▷ 数组的遍历
遍历:
一个一个的访问数组的元素,可以通过 for
循环进行遍历
比如在不知道数组中有多少元素的情况下,并且想计算元素加起来的和是多少
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int ages[ ] = {
10 , 20 , 30 , 40 } ;
int count = 0 ;
for ( int i = 0 ; i < ages. length; i++ ) {
count += ages[ i] ;
}
System . out. println ( count) ;
}
}
▷ 动态初始化数组
动态化数组:
就是定义数组时不存入元素的具体值,只确定数组存储的数据类型和数组的长度
适合开始不确定具体元素值,只知道元素个数的业务场景
格式: 数据类型[] 数组名 = new 数据类型[长度]
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
String [ ] names = new String [ 3 ] ;
names[ 0 ] = "飞兔小哥" ;
names[ 1 ] = "博客专家" ;
names[ 2 ] = "天猫精灵测评官" ;
System . out. println ( names[ 0 ] ) ;
System . out. println ( names[ 1 ] ) ;
System . out. println ( names[ 2 ] ) ;
}
}
▷ 数组求最值
比如给一个整型数组,求其中的最大值
就是遍历数组,判断每个值如果比前一个值大,就把大的值赋值给变量
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int age[ ] = {
10 , 20 , 40 , 30 } ;
int max = age[ 0 ] ;
for ( int i = 0 ; i < age. length; i++ ) {
if ( age[ i] > max) max = age[ i] ;
}
System . out. println ( "最大值为:" + max) ;
}
}
▷ 数组反转
比如给一个整型数组 {10, 20, 40, 30}
将其反转变成 {30, 40, 20, 10}
原理就是先将第一个元素和最后一个元素调换位置后,然后将第二个元素和倒数第二个元素进行交换,然后一直下去即可
可以定义两个变量 i和j
,其中 i
默认值从第一个元素向右移动,j
默认最后一个元素向左移动,每处理一次将其中两个元素位置进行互换即可
▷ debug工具
在写程序的时候,可以看到编辑器已经很直观的给你进行错误提示了
但是如果想查看运行过程中,数值的变化情况,就需要用到编辑器的 debug
工具了
首先,需要在 行号
上面打个断点,然后右键选择 debug
运行,点击运行按钮,即可在编辑器中看到数组的变化了,非常的清晰
▷ 方法
方法:
是一种语法结构,把一段代码封装成一个功能,以便重复调用
方法
可以提高代码的重复性,提高开发效率,也可以让程序的逻辑更加的清晰
方法的定义格式: 修饰词 返回值类型 方法名(形参列表) { 代码; return 返回值; }
注意: 方法如果申明了具体的返回值类型,那么内部 return 必须返回对应的数据类型
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int count = sum ( 1 , 2 ) ;
System . out. println ( count) ;
}
public static int sum ( int a, int b) {
return a + b;
}
}
▷ 返回值
如果定义的方法没有返回值,那么返回值的类型就需要定义成 void
如果定义的方法有返回值,那么内部 return 必须返回对应的数据类型
形参列表可以有多个,甚至没有;如果有多个形参,需要用逗号隔开,且不能给初始化值
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int count = sum ( 1 , 2 ) ;
System . out. println ( count) ;
say ( ) ;
}
public static void say ( ) {
System . out. println ( "我是飞兔小哥" ) ;
}
public static int sum ( int a, int b) {
return a + b;
}
}
▷ 求和
求 1到n的和
是有返回值的,也就是需要打印最终的和
由小学求和公式可知,求1到n的和的公式为:(1+n)*n/2
因为最终的和是整数,所以需要定义返回类型为 int
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int count = sum ( 100 ) ;
System . out. println ( count) ;
}
public static int sum ( int n) {
return ( 1 + n) * n / 2 ;
}
}
▷ 奇偶性
判断一个数的奇偶性,只需要打印结果即可,不需要返回值的
这个时候就可以将返回值的类型定义为 void
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
judge ( 51 ) ;
judge ( 60 ) ;
}
public static void judge ( int number) {
if ( number % 2 == 0 ) {
System . out. println ( number + "是一个偶数" ) ;
} else {
System . out. println ( number + "是一个奇数" ) ;
}
}
}
▷ 参数传递
值传递:
指的是在传输实参给方法中的形参的时候,传输的是实参变量中存储的值的副本,修改副本中参数的值,并不会改变实参的值
引用值传递:
传输给形参的时候,传的是实参的地址,修改值之后,会改变实参中的值,比如数组就是引用传递
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int a = 20 ;
change ( a) ;
System . out. println ( a) ;
}
public static void change ( int a) {
System . out. println ( a) ;
a = 520 ;
System . out. println ( a) ;
}
}
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
int a[ ] = {
10 , 20 , 30 } ;
change ( a) ;
System . out. println ( a[ 1 ] ) ;
}
public static void change ( int [ ] a) {
System . out. println ( a[ 1 ] ) ;
a[ 1 ] = 520 ;
System . out. println ( a[ 1 ] ) ;
}
}
▷ 方法重载
方法重载:
是在一个类中,多个方法的 名称相同
,但是它们的 形参列表不同
,其他的不用管,比如修饰符、返回值类型等。
形参列表的不同:
指的是形参的个数、类型、顺序不同,不关心形参的名称
比如游戏中创建 NPC
,并且给 NPC
设置血量
package tiny. geeker ;
public class Test {
public static void main ( String [ ] args) {
System . out. println ( create ( "飞兔小哥" ) ) ;
System . out. println ( create ( "飞兔小哥" , 10000 ) ) ;
}
public static String create ( String name) {
return "创建了NPC:" + name;
}
public static String create ( String name, int blood) {
return "创建了NPC:" + name + ",血量为:" + blood;
}
}
▷ 案例:创建验证码
指定程序生成 n
位数的验证码,然后程序会随机返回 n
位数的字符串
package tiny. geeker ;
import java. util. Random ;
public class Test {
public static void main ( String [ ] args) {
String code = qrcode ( 5 ) ;
System . out. println ( code) ;
}
public static String qrcode ( int n) {
String code = "" ;
Random r = new Random ( ) ;
for ( int i = 0 ; i < n; i++ ) {
int type = r. nextInt ( 3 ) ;
switch ( type) {
case 0 :
code += r. nextInt ( 10 ) ;
break ;
case 1 :
char ch1 = ( char ) ( r. nextInt ( 26 ) + 97 ) ;
code += ch1;
break ;
case 2 :
char ch2 = ( char ) ( r. nextInt ( 26 ) + 65 ) ;
code += ch2;
break ;
}
}
return code;
}
}