需求:
在数组里存人名和成绩
{“张迪”,”100”}
{“c”,”45”}
{“王”,”101”,”张”,”152”}
{{"张迪","100"},{"c","45"},{"1","5","56"}}
———-引申出概念:二维数组
概念:数组的元素依然是数组
int[] a={1,2,3,4}
int[][] b={{1,2,},{3,4,}}
访问: b[0]–>{1,2}
b[1]–>{2,3,4,5,6}
b[2]–>{1,2,3}
b[0][0] -->1
b[0][1] -->2
.....
b[1][3] -->5
b[1][4] -->6
...
b[2][1] -->2
x={
{1,2,3},
{1,2,3},
{4,5,6}
}
x数组的元素:都是等长的数组,类似于矩阵。
y ={
{1,2},
{1,2,3},
{1}
}
y数组的元素:不是等长的数组。
方法内:
引用数据类型与基本数据类型的区别:
引用数据类型的 数据 称之为对象,存储在内存中某一个特定区域中,即堆
引用类型的 变量 也存储在内存中的一个特定区域,即栈
引用类型的变量 存储的内容 不是 对象 ,而是对象所在的 堆空间 的位置信息
基本类型的数据不叫对象,直接存储在栈的变量空间里(不需要通过栈存堆位置信息)
基本数据类型的数据存在栈里,存储的内容是基本类型的数据
二维数组初始化;
静态初始化
如:int[][] a = {{1,2},{1,2,3}{1,2,3,4,5}};
动态初始化:
(1)等长初始化
int[][] a = new int[3][2];//a有三个元素,每个元素都是2个长度的数据
(2)只规定高维数组的长度
int[][] a = new int[3][];
表示a有三个元素,但是都是null.
null在使用时,需要新建数组对象(长度任意)
a[0] = new int[2];//将null替换成数组对象
====================================================================
方法:即功能,封装了一段逻辑代码
方法的定义:
固定语法:
修饰词 返回值类型 方法名(形式参数){
逻辑代码
}
方法的位置:
在类体中,与main方法是并列关系,类体中可以有多个方法
修饰词:public----公共的
protected---受保护的
private---私有的
也可以不写修饰词,即默认的(default)
static修饰词可以与上述三个连用
返回值类型:
(1)void-----无返回值类型
(2)java语言的任意一种类型,可以是基本数据类型,也可以是引用数据类型
方法名:见名知义,驼峰命名法,首字母小写
形式参数;
用于接收调用者传入的数据。与变量的声明语法相同。
关键字return:
作用1:结束方法逻辑
作用2:如果返回值类型标记的是java语言类型的某一个类型名,
那么return关键字后必须跟着一个 此类型的数据或变量
当方法有返回值类型时,return关键字后的数据就是此方法要返回的数据,
返回给调用者。
如:public static int sum(){
int a = 3;
int b = 5;
int sum = a+b;
return sum;
例1:(无返回值用void) //方法中变量已赋值,调用时直接调用sum()
public static void sum(){
int a = 3;
int b = 5;
System.out.println(a+b);
[return;]—返回值类型处写void时,return可有可无;
}
调用:
main(String[] args){
sum();
}
例2:计算两个整数a和b的和 (无返回值用void) //变量未赋值,方法中需要形参
public static void sum(int a,int b){
//括号内为形式参数
int sum = a+b;
System.out.println(sum);
}
PS: 方法定义期间,就是制定逻辑流程模板。
调用:
main(String[] args){
/*
调用者main 在使用sum(int a,int b)时
需要给形式参数赋值,赋的值叫实际参数
*/
int x = 1;
int y = 2;
sum(x,y);
}
例3.//有返回值,方法中变量已赋值,调用时直接调用sum()
public static int sum(){
int a = 3;
int b = 5;
int sum = a+b;
return sum;
}
调用:main(String[] args){
sum();
/*int n = sum();*/ //暂时不用时可以用变量存起来
}
例4.有返回值,需要形参
public static int sum(int a ,int b){
int sum = a+b;
return sum*3;
}
调用:main(String[] args){
int m = 10;
int n = 20;
int s = sum(m,n);
}
总结;
调用方法时:
---- 无返回值 方法名(有参传参,即方法中有参数,调用时传实参);
—–有返回值 返回值类型 变量=方法名(有参传参,即方法中有参数,调用时传实参);
eclipse(日食):
是eclipse基金会提供的一款集成开发环境(IDE)。
也是一款绿色免安装,免费的开发工具。
使用前,需要JDK开发环境。
其他开发工具如:myeclipse,ideas,netBean,JBiulder
使用步骤:
(1)新建项目
File–>new–>java Project–name–>finish
(2)新建包(package)
命名规则
域名后缀.域名.项目名.模块名
src–>new–>package–name–finish
(3)创建源文件(.java)
选中包–>new–>class–name–finish
补全键: alt+ ?
main方法的快捷方式
main+补全键
syso+补全键
ctrl + s的习惯
例1./* 二维数组得声明和初始化 概念:数组得元素依然输一个数组 /
import java.util.Arrays;// 导包
public static void main(String[] args){
/二维数组得声明和初始化/
/*静态初始化:*/
int[][] a= {{1,2},{3,4,5},{6,7}};
/*使用 for循环进行遍历*/
for(int i=0;i<a.length;i++){
int[] n=a[i];//n是一个数组,存储的是a[i]的位置
/* System.out.println(Arrays.toString(n)); */
for(int j=0;j<n.length;j++){
int m=n[j];//内层循环的位置
System.out.print(n[j]+"");
//双层for循环,最终答案从内层循环输出
}
System.out.println();4ihh
}
/*动态初始化
二维数组等长式初始化,考虑数组下标越界*/
int[][] b= new int[6][5];
//访问输出第一个数组
System.out.println(Arrays.toString(b[0]));
b[0][0] = 1;//替换元素
//b[0][6]=7;
System.out.println(Arrays.toString(b[0]));
/*动态初始化
只规定了高维的长度时,里面的元素是null,不能直接给null赋值,
应该先把null替换成相应的数组对象*/
int[][] c= new int[3][];//有三个数组,分别为默认值
//输出第一个元素
System.out.println(c[0]);//null
c[0] = new int[2];//将null替换成数组对象
System.out.println(Arrays.toString(c[0]));
c[0][0] = 1;
c[0][1] = 2;
System.out.println(c[0]);
System.out.println(Arrays.toString(c[0]));
c[1] = new int[3];//内层第二个数组长度为3
c[1][1] = 4;//内层第二个数组,第二个元素为4
System.out.println(Arrays.toString(c[1]));//输出:0 4 0
c[2] = new int[2];//内层第三个数组长度为2
System.out.println(Arrays.toString(c[2]));//输出:0 0
}
例2. 方法的封装及调用
/** 计算半径为r的圆的周长:length */
public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
length(5); //---------方法调用
length(6);
length(7);
length(100);
}
public static void length(double r){ //-------方法封装
//无返回值,用形参
double length = r*2*3.14;
System.out.println(length);
}
//方法封装与main方法并列
例3. 方法的封装及调用
/** 返回半径为r的圆的面积:area */
public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
double area = area(9); //---------方法调用
System.out.println(area);
System.out.println(area(10));
System.out.println(area(100));
}
public static double area(double r){ //-------方法封装
//有返回值,
return 3.14*r*r;
}
例4. 方法的封装及调用
/** 返回宽为3,高为5的方形的面积 area_square */
public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
area_square(); //---------方法调用
}
public static void area_square(){ //-------方法封装
//有返回值,用void
System.out.println(3*5);
}
例5. 方法的封装及调用
/** 返回一个字符数组,元素为随机7个小写字母 randomArr */
import java.util.Arrays;//导包
public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
char[] a = randomArr(); //———方法调用
char[] b = randomArr();
Arrays.sort(a);//从小都大排序
Arrays.sort(b);
System.out.println(Arrays.toString(a));//对数组a进行字符输出
System.out.println(Arrays.toString(b));
}
public static char[] randomArr(){ //-------方法封装
//有返回值
char[] chs = new char[7];//返回字符数组,得先定义一个字符数组,长度为7
for(int i=0;i<chs.length;i++){
chs[i]=(char)(Math.random()*26+97);
}
return chs;
}
例6. 方法的封装及调用
/** 定义一个猜数字的方法:被猜的数字由形参决定:
直到猜中为止。范围[1,100] guessNum */
import java.util.Scanner;//导包
public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
int num = (int)(Math.random()*100+1); //———方法调用
guessNum(num);
}
public static void guessNum(int num){ //-------方法封装
Scanner sc = new Scanner(System.in);//键盘输入
int guess = -1;
do{
System.out.println("输入您猜的数字:");
guess = sc.nextInt();
if(guess>num){
System.out.println("猜大了");
}
if(guess<num){
System.out.println("猜小了");
}
}while(guess!=num);
System.out.println("猜中了,游戏结束");
}
例7. 关键字
/*随便出10道加法题,加数在[1,100]区间内并作答,
每道题答对得10分,*/
public static void main(String[] args){
int total_score = 0;
Scanner sc = new Scanner(System.in);
for(int i=1;i<11;i++){
int a = (int)(Math.random()*100+1);
int b = (int)(Math.random()*100+1);
System.out.print("请答题: ");
System.out.print(a+"+"+b+"=");
int input = sc.nextInt();
if(input==(a+b)){
total_score+=10;
}
}
System.out.println("total_score:"+total_score);
}
例8.
/* 录入10个学生的数学,语文,英语三科成绩
计算每科的平均成绩与每人的平均成绩
并找出每科成绩的最高分与最低分。
*/
import java.util.Scanner;
import java.util.Arrays;
public class TestDemo02{
public static void main(String[] args){
int[][] scores = new int[5][3];
Scanner sc = new Scanner(System.in);
for(int i=0;i<scores.length;i++){
System.out.println("录入第"+(i+1)+"个学生的成绩");
for(int j=0;j<scores[i].length;j++){
scores[i][j]=sc.nextInt();
}
}
/*查看 每个学生的成绩*/
for(int i=0;i<scores.length;i++){
System.out.println("学生"+(i+1)+":"+Arrays.toString(scores[i]));
}
/*计算每个学生的总成绩和平均成绩
int sum = 0;
sum+=scores[0][0];
sum+=scores[0][1];
sum+=scores[0][2];
sum/3.0;
int sum = 0;
sum+=scores[1][0];
sum+=scores[1][1];
sum+=scores[1][2];
sum/3.0;
.....
*/
for(int i=0;i<scores.length;i++){
int sum = 0;
for(int j=0;j<scores[i].length;j++){
sum+=scores[i][j];
}
System.out.println("学生"+(i+1)+"的总成绩:"+sum+",平均成绩:"+(int)((sum/3.0)*100)/100.0);
}
/*
计算每科的总成绩和平均成绩
int total_sum = 0;
total_sum+=scores[0][0];
total_sum+=scores[1][0];
total_sum+=scores[2][0];
total_sum+=scores[3][0];
total_sum+=scores[4][0];
total_sum+=scores[5][0];
.....
total_sum/10.0
int total_sum = 0;
total_sum+=scores[0][1];
total_sum+=scores[1][1];
total_sum+=scores[2][1];
total_sum+=scores[3][1];
total_sum+=scores[4][1];
total_sum+=scores[5][1];
.....
total_sum/10.0
int total_sum = 0;
total_sum+=scores[0][2];
total_sum+=scores[1][2];
total_sum+=scores[2][2];
total_sum+=scores[3][2];
total_sum+=scores[4][2];
total_sum+=scores[5][2];
.....
total_sum/10.0
*/
/*
顺便统计每科的最高分与最低分
*/
for(int i=0;i<scores[0].length;i++){
int total_sum = 0;
int max = -1;
int min = 101;
for(int j=0;j<scores.length;j++){
total_sum+=scores[j][i];
if(max<scores[j][i]){
max = scores[j][i];
}
if(min>scores[j][i]){
min = scores[j][i];
}
}
System.out.println("学科"+(i+1)+"的总成绩:"+total_sum+",平均成绩:"+total_sum/10.0+",最高分:"+max+",最低分:"+min);
}
}
}