[TOC]

• 以下学习内容均来自传智播客基础课程。

二维数组

• 格式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个元素
• 注以下格式也可以表示二位数组（不推荐使用）
  • 数据类型 数组名[][] = new 数据类型][m][n];
  • 数据类型 数组名][] = new 数据类型][m][n];

class Array2Demo{
    public static void main(String[] args){
        int [][] arr = new int[3][2];
        System.out.println(arr);
        
        System.out.println(arr[0]); //arr的第1个一维数组名称.
        System.out.println(arr[1]); //arr的第2个一维数组名称.
        System.out.println(arr[2]); //arr的第3个一维数组名称.
        
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        
    }
}

• 格式2（动态初始化）
  • 数据类型[][] 变量名 = new 数据类型[m][];
  • m表示这个二维数组有多少个一维数组
  • 这一次没有直接给出一维数组的元素个数，可以动态的给出。
  • 举例：
    • int[][] arr = new int[3][];
    • arr[0] = new int[2];
    • arr[1] = new int[3]
    • arr[2] = new int[1];

• 格式3（静态初始化）
  • 数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
• 简化版格式：
  • 数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
  • 举例：
  • int[][] arr = {{1,2,3},{4,6},{6}};

二维数组练习

• 二维数组遍历

//For循环实现
class Array2Test{
    public static void main(String[] args){
        int[][] arr ={{1,2,3},{4,5,6},{7,8,9}};
        for(int x=0;x<arr.length;x++){
            for(int y=0;y<arr[x].length;y++){
                System.out.print(arr[x][y]+"\t");
            }        
            System.out.println();
        }
    }
}

//函数实现
class Array2Test{
    public static void main(String[] args){
        int[][] arr ={{1,2,3},{4,5,6},{7,8,9}};
        printArray2(arr);
    }
    
    public static void printArray2(int[][] arr){
        for(int x=0;x<arr.length;x++){
            for(int y=0;y<arr[x].length;y++){
                System.out.print(arr[x][y]+"\t");
            }        
            System.out.println();
        }
    }    
}

• 二维数组求和
  • 某公司按照季度和月份统计的数据如下：单位(万元)
    • 第一季度：22,66,44
    • 第二季度：77,33,88
    • 第三季度：25,45,65
    • 第四季度：11,66,99

class Array2Test{
    public static void main(String[] args){
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        System.out.println(sum(arr)+"万");
    }
    
    public static int sum(int[][] arr){
        int sum =0;
        for(int x=0;x<arr.length;x++){
            for(int y=0;y<arr[x].length;y++){
                sum += arr[x][y];
            }
        }
        return sum;
    }
}

• 打印杨辉三角形(行数可以键盘录入)

1:杨辉三角形

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

分析：
A:如果是n行，那么最后一行是n列。
B:每一行的第一列和最后一列的元素是1。
C:规律：

• 每一行的第二列开始数据是：上一行的上一列 + 上一行的同一列

D:把二维数组组成，然后遍历即可。
遍历的时候，注意模仿九九乘法表的遍历。否则会有很多0。

import java.util.Scanner;
class Array2Test{
    public static void main(String[] args){
        Scanner sc =new Scanner(System.in);
        
        int n = sc.nextInt();
        
        int [][] arr = new int[n][n];
        for(int x=0;x<arr.length;x++){
            arr[x][0] = 1;
            arr[x][x] = 1;
        }
        
        for(int x=2;x<arr.length;x++){
            for(int y=1;y<=x-1;y++){
                arr[x][y] = arr[x-1][y-1]+arr[x-1][y];
            }
        }
        
        for(int x=0;x<arr.length;x++){
            for(int y=0;y<=x;y++){
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
    }
}

• 思考题：1:参数传递问题
  • Java中的数值传递问题
    • 基本类型：形式参数的改变对实际参数没有影响。（传递的是参数值）
    • 引用类型：形式参数的改变直接影响实际参数。（传递的是地址值）

public static void main(String[] args)
{
    int a = 10;
    int b = 20;
    System.out.println("a:"+a+",b:"+b);
    change(a,b);
    System.out.println("a:"+a+",b:"+b);

    int[] arr = {1,2,3,4,5};
    change(arr);
    System.out.println(arr[1]);
}

public static void change(int a,int b)  
{
    System.out.println("a:"+a+",b:"+b);
    a = b;
    b = a + b;
    System.out.println("a:"+a+",b:"+b);
}

public static void change(int[] arr)
{
    for(int x=0; x<arr.length; x++)
    {
        if(arr[x]%2==0)
        {
            arr[x]*=2;
        }
    }
}

• 思考题2
  • 某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：
    • 首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
    • 最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
    • 然后，把加密后的结果在控制台打印出来。

import java.util.Scanner;
class JiaMiDemo{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        System.out.println("Please input a number:");
        
        int number = sc.nextInt();
        
        String result = jiaMi(number);
        System.out.println("Jia mi result is:"+result);
    }
    
    public static String jiaMi(int number){
        int[] arr = new int[8];
        
        int index = 0;
        
        while(number>0){
            arr[index] = number % 10;
            index++;
            number /= 10;
        }
        
        for(int x=0;x<index;x++){
            arr[x] +=5;
            arr[x] %=10;
        }
        
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;
        
        String s="";
        
        for(int x=0;x<index;x++){
            s+=arr[x];
        }
        
        return s;
    }
}

[========]

第四章 面向对象

• 本章重点
  • 面向对象思想
  • 类与对象及其使用
  • 对象的内存图
  • 成员变量和局部变量的区别
  • 匿名对象
  • 封装(private)
  • this关键字
  • 构造方法
  • static关键字

面向对象思想

• 吃饭：

  • 面向过程：去超市买菜->摘菜->洗菜->切菜->炒菜->盛起来->吃
  • 面向对象：上饭店吃饭，你->服务员(点菜)->厨师(做菜)->服务员(端菜)->吃

• 面向对象：

  • 我们怎么才能更符合面向对象思想呢?
    • A:有哪些类呢?
    • B:每个类有哪些东西呢?
    • C:类与类直接的关系是什么呢?

• 把大象装进冰箱的分析? (如何分析有哪些类呢?UML。名词提取法。)

  • A:有哪些类呢?
    • 大象
    • 冰箱
    • Demo
  • B:每个类有哪些东西呢?
    • 大象：
      • 进去
    • 冰箱：
      • 开门
      • 关门
    • Demo:
      • main方法
  • C:类与类直接的关系是什么呢?
    • Demo中使用大象和冰箱类的功能。

• 代码体现：

class 大象 {
public static void in() {
System.out.println("装进大象");
}
}

class 冰箱 {
public static void open() {
System.out.println("打开冰箱门");
}

public static void close() {
System.out.println("关闭冰箱门");
}
}

class Demo {
    public static void main(String[] args) {
        冰箱调用开门
        大象调用进去
        冰箱调用关门
    }
}

如何更符合面向对象思想

• A:首先分析有那些类
• B:接着分析每个类应该有什么
• C:最后分析类与类的关系

面向对象开发,设计,特征

• 面向对象开发

  • 就是不断的创建对象，使用对象，指挥对象做事情。

• 面向对象设计

  • 其实就是在管理和维护对象之间的关系。

• 面向对象特征

  • 封装(encapsulation)
  • 继承(inheritance)
  • 多态(polymorphism)

• 如何表示一个现实世界事物呢：

  • 属性 就是该事物的描述信息
  • 行为 就是该事物能够做什么

类

• 类：是一组相关的属性和行为的集合，是一个抽象的概念。

• 对象：是该类事物的具体表现形式，具体存在的个体。

• 定义类其实就是定义类的成员(成员变量和成员方法)

• Java中用class描述事物也是如此

  • 成员变量 就是事物的属性
  • 成员方法 就是事物的行为

• 如何使用

  • 创建对象：
    • 类名 对象名 = new 类名();
  • 对象名.成员变量
  • 对象名.成员方法

一个对象的内存图

• 一个对象的基本初始化过程

class Phone{
    //品牌
    String brand;    
    //价格
    int    price;
    //颜色
    String color;
    
    //打电话的方法
    public void call(String name){
        System.out.println("Call"+name);
    }
    
    public void sendMessage(){
        System.out.println("Send Message!!!");
    }
    
    public void playGame(){
        System.out.println("Play Game!!!");
    }
}

class PhoneDemo{
    public static void main(String[] args){
        Phone p =new Phone();
        
        p.brand = "Nokia";
        p.price = 100;
        p.color = "Yellow";
        
        p.call("Chenlixiang~~");
        p.sendMessage();
        p.playGame();
        
        System.out.println(p.brand +"---"+p.price+"---"+p.color);
    }
}

两个对象的内存图

• 注：方法在方法区中内存地址的共用问题。

  
  

三个对象的内存图

• 注：两个引用指向同一个对象