今天是我在乐字节学习的第七天拉,老师讲课很幽默风趣哦，是我喜欢滴类型，每天学习都倍有劲儿~~简直太爱了，今天老师讲课的主要内容是：
一、二维数组概述和格式1(理解)
A:二维数组概述
我们学校的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。
这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用
由此可见：其实二维数组其实就是每一个元素为一维数组的数组。
B:二维数组格式1
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选
举例:
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
C:注意事项
A:以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
B:注意下面定义的区别
int x,y;
int[] x,y[];
区别是:
int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
x=new int[3];
y=new int[3][];
D:案例演示
定义二维数组，输出二维数组名称，输出每一个一维数组名称，输出二维数组的2个元素
123456789101112131415161718192021222324252627282930
二维数组格式2(理解)
A:二维数组格式2
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];
B:案例演示
定义一个二维数组,输出二维数组的名称和二维数组的的每一个一维数组,然后动态给二维数组赋值一维数组
再次输出二维数组中的每一个一维数组,给二维数组中的元素赋值,输出对应的元素值
123456789101112
二维数组格式3(理解)
A:二维数组格式3
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
简化版:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
举例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};
B:案例演示
定义一个二维数组,打印每一个二维数组中的一维数组,在打印每一个二维数组中的元素
12345678910
public static void main(String[] args) {
//二维数组的静态初始化：由我们给元素赋值，有系统计算长度
int[][] arr=new int[][]{{20,30},{1,3},{100,200,300}};
System.out.println(arr.length);
System.out.println(arr[2][2]);
//数组中最后一个元素的索引=数组的长度-1
System.out.println(arr[arr.length-1][arr[arr.length - 1].length-1]);
//静态初始化的简写
double[][] arr2={{2,30},{2.14,3.4},{1L,3.1F}};
double[] minArr=arr2[0];
System.out.println(minArr[0]);
}
123456789101112
二维数组练习1遍历(理解)
public static void main(String[] args) {
int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
/* System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[0][2]);
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
System.out.println(arr[1][2]);
System.out.println(arr[2][0]);
System.out.println(arr[2][1]);
System.out.println(arr[2][2]);*/
//二维数组的遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
12345678910111213141516171819202122
二维数组练习2求和(理解)
public static void main(String[] args) {
/* A:
案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度： 22,66, 44
第二季度：77, 33, 88
第三季度：25, 45, 65
第四季度：11, 66, 99*/
//遍历二维数组元素求和
//动态初始化
int[][] arr = new int[4][3];
arr[0]=new int[]{22, 66, 44};
arr[1] = new int[]{77, 33, 88};
arr[2]= new int[]{25, 45, 65};
arr[3]=new int[]{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+"万元");
System.out.println("===================================");
int[][] arr2={{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
int sum2 = 0;
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[i].length; j++) {
sum2 += arr2[i][j];
}
}
System.out.println("总计：" + sum2 + "万元");
}
1234567891011121314151617181920212223242526272829303132333435
public static void main(String[] args) {
/* B:需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
看图分析规律：1.每一行的首尾都是1
2.从第三行开始，从第二列开始，中间的数字=他上一行的前一列和上一行的本列之和。
我们使用二维数组，来存储每一行的数据
* */
Scanner sc = new Scanner(System.in);
System.out.println("请输入行数");
int n = sc.nextInt();
//我们假定行数和列数都相等
int[][] arr=new int[n][n];
//1.每一行的首尾都是1
for (int i = 0; i < arr.length; i++) {
arr[i][0]=1;
arr[i][i]=1;
}
//2. 从第三行开始，从第二列开始，中间的数字 = 他上一行的前一列和上一行的本列之和。
for (int i =2; i < arr.length; i++) {
for (int j =1; j arr[i][j]=arr[i-1][j-1]+ arr[i - 1][j]; } } //3.打印三角形 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(); } } 123456789101112131415161718192021222324252627282930313233343536 二、Java中的参数传递问题及图解(掌握) public static void main(String[] args) { //参数的传递问题 //基本类型作为参数传递，属于值传递，会把这个变量的值传过去。 //引用类型作为参数传递，属于引用传递，传递的是地址值。 //基本类型作为参数传递，形参的改变，不影响实参。 //引用类型作为参数传递，形参的改变，会影响实参 //定义两个int边路 int a = 10; int b = 20; //输出变量的值 System.out.println("a: " + a + ",b: " + b); //1. 10 20 //调用方法，把 a 和 b 传过去 change(a, b); //输出变量的值 System.out.println("a: " + a + ",b: " + b); //4.20 40 / 10 20 //定义一个数组 int[] arr =new int[]{1, 2, 3, 4, 5}; //调用方法，把数组传过去 System.out.println("传递的arr"+arr); change(arr); //输出数组中第二个元素的值 System.out.println(arr[1]); //5. 4 } public static void change(int a, int b) { System.out.println("a: " + a + ",b: " + b); //2.a 10 b 20 a = b; //a 20 b = a + b; System.out.println("a: " + a + ",b: " + b); //3.20 40 } public static void change(int[] arr) { System.out.println("收到的arr:" + arr); for (int x = 0; x < arr.length; x++) { if (arr[x] % 2 == 0) { arr[x] *= 2; } } } 1234567891011121314151617181920212223242526272829303132333435363738 三、递归 A:递归概述: 方法定义中调用方法本身的现象 B:递归注意事项 要有出口，否则就是死递归 次数不能太多，否则就内存溢出 C:递归举例: 我们学编程… 12345 public static void main(String[] args) { //递归：在方法中调用方法本身的一种现象。 //递归需要注意的：1.递归要有出口，不然就是死递归，死递归会造成栈溢出。 //2.递归次数不宜过多，过多也会有栈溢出的可能。 //3.递归体现的是一种拆分合并的思想。 //生活中的递归：从前有座庙，.... //学Java---找工作---挣钱----娶媳妇----生娃----学Java----找工作---挣钱---娶媳妇 diGUi(50); } private static void diGUi(int num) { //StackOverflowError 栈溢出 System.out.println("递归"); num--; if(num<0){ return; }else{ diGUi(num); } } 12345678910111213141516171819 递归求阶乘的代码实现(理解) public static void main(String[] args) { //求5的阶乘 5*4*3*2*1 /* int num=5*4*3*2*1; System.out.println(num);*/ int num = 1; for (int i = 5; i >= 1; i--) { num *= i; } System.out.println(num); } 12345678910 public static void main(String[] args) { //递归的思想来做5的阶乘 int r=jieCheng(5); System.out.println("结果"+r); } public static int jieCheng(int i) { if(i==1){ return 1; }else{ return i*jieCheng(i-1); } } 123456789101112 (不死神兔问题)(理解) public static void main(String[] args) { /*A: 案例演示: 需求：兔子问题(斐波那契数列) 有一对兔子，从出生后第3个月起每个月都生一对兔子， 小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？ 月份 兔子的对数 1 1 2 1 3 2 4 3 5 5 6 8 7 13 8 21 */ // 1 1 2 3 5 8 13 21 34 斐波那契数列 //斐波那契数列:从第三个数开始，这个数等于前两个数之和 //普通的方式来做 int[] arr=new int[20]; arr[0]=1; arr[1]=1; //从第三个数开始，这个数等于前两个数之和 for (int i = 2; i < arr.length; i++) { arr[i]=arr[i-1]+arr[i-2]; } System.out.println(arr[19]); } 12345678910111213141516171819202122232425262728 public static void main(String[] args) { //用递归来做一下不死神兔子 int sum=rabbit(20); System.out.println(sum); } private static int rabbit(int i) { if(i==1||i==2){ return 1; }else{ return rabbit(i-1)+rabbit(i-2); } } 123456789101112 四、面向对象 面向对象思想概述(理解) A:面向过程思想概述我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。面向过程的代表语言：C语言B:面向对象思想概述当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。C:面向对象思想特点a:是一种更符合我们思想习惯的思想 懒人思想b:可以将复杂的事情简单化c:将我们从执行者变成了指挥者角色发生了转换 public static void main(String[] args) { //面向对象的思想 //面向对象：基于面向过程，他把这些过程封装起来。去调用。 //面向对象的三大特征：封装 基础 多态 //我们学习编程是为了什么 // 我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。 //现实世界中，由万事万物所构成 //事物-----------对应Java中------ 类 class //属性---------------------------成员变量（成员属性） //功能---------------------------成员方法（成员功能） //如何定义一个类，使用关键字class //人类 Person //那么我们在测试类中，使用我们定义的人类中属性和功能。 //类，他是一个抽象的概念。不能直接使用，要使用类中的属性和方法，必须完成对类的实例化 //所谓实例化，就是创建该类对象，那么怎么来创建该类的对象呢。我们使用关键字 new 来完成。 //我们有了该类的对象后。对象才是一个类的具体表现。有了对象，我们就可以使用对象来调用类中的属性和功能了。 //当然一个类可以创建很多对象。 //创建Person类的对象 //类名 对象名=new 类名() Person person=new Person(); //使用对象来 调用类中的属性和功能 //通过对象，获取属性的值 String mingzi=person.name; int nianling= person.age; char ch=person.sex; System.out.println(mingzi); System.out.println(nianling); System.out.println(ch); //调用类的功能 对象名.方法名() person.eat(); person.sleep(); person.playGame(); System.out.println("============================"); //再创建一个Person类的对象 Person p1 = new Person(); p1.name="李四"; p1.age=30; p1.sex='女'; System.out.println(p1.name); System.out.println(p1.age); System.out.println(p1.sex); p1.sleep(); p1.eat(); p1.playGame(); } 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950 面向对象思想举例(理解) A:举例:洗衣服：换下脏衣服—盛水----浸泡------手搓----漂清—晾干全自动洗衣机----------- 一键洗衣吃饭B:面向对象特征封装(encapsulation)继承(inheritance)多态(polymorphism)C:面向对象开发就是不断的创建对象，使用对象，指挥对象做事情。 面向对象(类与对象概述)(理解) A:我们学习编程是为了什么 我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。 B:我们如何描述现实世界事物 举例: 描述学生事物 姓名 , 年龄 , 性别 .... 学习 , 吃饭 , 睡觉 .... 属性: 就是该事物的描述信息 行为: 就是该事物能够做什么 我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。 由此我们就得到了现实中的事物和类的对应关系 事物 类 属性 ----------------- 成员变量 行为 ----------------- 成员方法 C:定义类其实就是定义类的成员(成员变量和成员方法) a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。 b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。 D:类和对象的概念 a:类：是一组相关的属性和行为的集合 b:对象：是该类事物的具体体现 c:举例： 类 学生 对象 班长就是一个对象 1234567891011121314151617181920212223 面向对象(学生类的定义)(掌握) A:学生事物属性: 姓名 , 年龄 , 地址 …行为: 吃饭 , 睡觉 , 上课 …B:学生事物与学生类的对应关系属性 ----- 成员变量行为 ----- 成员方法 //定义一个类 public class Person { //定义成员变量：定义在类中，方法外 String name = "张三"; int age = 23; char sex = '男'; //定义成员方法，你以前怎么定义方法的，那现在你也把static去掉 public void sleep() { System.out.println("睡觉"); } public void eat() { System.out.println("吃饭"); } public void playGame() { System.out.println("玩游戏"); } } 1234567891011121314151617 面向对象(手机类的定义)(掌握) //定义手机类 public class Phone { //定义成员变量 String brand="小米"; double price=799.9; String color="白色"; //定义成员方法 public void call(String name){ System.out.println("给"+name+"打电话"); } public void sendMsg(String name,String content) { System.out.println("给" + name + "发短信 内容是"+content); } } 1234567891011121314 面向对象(学生类的使用)(掌握) A:文件名问题在一个java文件中写两个类：一个基本的类，一个测试类。建议：文件名称和测试类名称一致。B:如何使用呢?创建对象使用。C:如何创建对象呢?格式：类名 对象名 = new 类名();D:如何使用成员变量呢?格式：对象名.变量名E:如何使用成员方法呢?格式：对象名.方法名(…) public static void main(String[] args) { Student student = new Student(); //成员变量没有赋值，有默认值 student.name="郭美美"; student.age=18; student.score=60; System.out.println(student.name); System.out.println(student.age); System.out.println(student.score); student.sleep(); student.eat(); System.out.println("==============================="); Student student2 = new Student(); student2.name = "杨超越"; student2.age = 30; student2.score = 50; System.out.println(student2.name); System.out.println(student2.age); System.out.println(student2.score); } 1234567891011121314151617181920 面向对象(手机类的使用)(掌握) public static void main(String[] args) { Phone phone = new Phone(); String brand = phone.brand; double price = phone.price; String color = phone.color; System.out.println(brand); System.out.println(price); System.out.println(color); //调用功能 phone.call("刘亦菲"); phone.sendMsg("王祖贤","小倩，我是宁采臣"); System.out.println("========================"); Phone phone2 = new Phone(); phone2.brand="魅族"; phone2.price=800; phone2.color="黑色"; String brand2 = phone2.brand; double price2 = phone2.price; String color2 = phone2.color; System.out.println(brand2); System.out.println(price2); System.out.println(color2); phone2.call("林青霞"); phone2.sendMsg("关之琳","十三姨，我是飞鸿"); } 1234567891011121314151617181920212223242526 面向对象(一个对象)(理解) public static void main(String[] args) { Student student = new Student(); System.out.println(student); student.name="王老虎"; student.age=50; student.score=3.14; String name=student.name; int age = student.age; double score = student.score; System.out.println(name); System.out.println(age); System.out.println(score); student.sleep(); student.eat(); } 123456789101112131415 面向对象(二个对象的内存图)(理解) public static void main(String[] args) { Student student = new Student(); student.name="沈某某"; student.age=18; student.score=80.88; System.out.println(student.name); System.out.println(student.age); System.out.println(student.score); System.out.println("==========================="); Student student2 = new Student(); student2.name = "沈员外"; student2.age = 38; student2.score = 99.99; System.out.println(student2.name); System.out.println(student2.age); System.out.println(student2.score); //输出对象的地址值 //每 new 一次都会在堆内存开辟新的空间 System.out.println(student); System.out.println(student2); } 123456789101112131415161718192021 面向对象(三个引用二个对象的内存图)(理解) public static void main(String[] args) { Student s1 = new Student(); s1.age = 30; s1.score = 62.3; Student s2 = new Student(); s2.name = "刘德华"; s2.age = 50; s2.score = 50.5; Student s3 = s1; s3.name = "郭富城"; System.out.println(s1.name); // System.out.println(s1.age); // System.out.println(s1.score); // System.out.println(s2.name); // System.out.println(s2.age); // System.out.println(s2.score); // System.out.println(s3.name); // System.out.println(s3.age); // System.out.println(s3.score); // //输出对象的地址值 System.out.println(s1); System.out.println(s2); System.out.println(s3); //判断 两个对象的地址值是否相等 System.out.println(s1==s2); System.out.println(s1==s3); }