今天是我在乐字节学习的第七天拉,老师讲课很幽默风趣哦，是我喜欢滴类型，每天学习都倍有劲儿~~简直太爱了，今天老师讲课的主要内容是：

一、二维数组概述和格式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 <i; 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);

}