java学习第六天

1:二维数组(理解)
    (1)元素是一维数组的数组。
    (2)格式：
        A:数据类型[][] 数组名 = new 数据类型[m][n];
            a:    int arr[][] = new int[4][3];
            b:    int[] arr[] = new int[4][3];
            c:    int[][] arr = new int[4][3];
            例：    int[] x,y[];//定义了一个x一维数组和一个y二维数组
            int[][] arr = new int[3][2];    //动态初始化
            System.out.println(arr);    //地址值
            System.out.println(arr[0]);    //一维数组arr[0]的地址
            System.out.println(arr[1]);    //一维数组arr[1]的地址
            System.out.println(arr[2]);    //一维数组arr[2]的地址
            System.out.println(arr[1][1]);    //一维数组arr[1]里的索引号为1存储的值
            
        B:数据类型[][] 数组名 = new 数据类型[m][];
            int[][] arr = new int[3][];    //列数没有给出，可以动态的给，这一次是一个变化的数
            System.out.println(arr[0]);    //null，因为还没有给定一位数组的元素个数，无法开辟空间
            System.out.println(arr[1]);    //null
            System.out.println(arr[2]);    //null
            arr[0] = new int[2];    
            arr[1] = new int[3];
            arr[2] = new int[1];
            System.out.println(arr[0]);    //一维数组arr[0]的地址，给定了元素个数，开辟内存空间
            System.out.println(arr[1]);    //一维数组arr[1]的地址
            System.out.println(arr[2]);    //一维数组arr[2]的地址
            
            
        C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};//静态初始化，不能与动态初始化同时存在
        D:数据类型[][] 数组名 = {{...},{...},{...}};//静态初始化
        int[][] arr = {{1,4,6},{3,8},{5}};//栈下面先开一个二维数组arr的空间，然后堆，先开三个数组的一维空间，每个空间值为null，各有一个地址，根据静态初始化的值很快开辟三个一维数组对应的元素的空间，每个一位数组有个地址，替代三个一位数组的null的地址值，如果访问栈里面的arr数组，则需要通过地址值访问到堆空间的相应空间。
        System.out.println(arr);
        System.out.println(arr[0]);    //null，因为还没有给定一位数组的元素个数，无法开辟空间
        System.out.println(arr[1]);    //null
        System.out.println(arr[2]);    //null
        
    (3)案例(掌握):
        A:二维数组的遍历
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
        //arr[0] = {1,2,3};
        //arr[1] = {4,5,6};
        //arr[2] = {7,8,9};
        System.out.print("{");
        for(int i=0;i<arr.length;i++){
            System.out.print("{");
            for(int j=0;j<arr[i].length;j++){
            if(j==arr[i].length-1){
                if(i==arr.length-1){
                    System.out.print(arr[i][j]+"}");
                }else{
                    System.out.print(arr[i][j]+"},");
                }
            }else{
                System.out.print(arr[i][j]+",");
            }
            }    
        }
        System.out.print("}");
        B:二维数组的求和
        public static int yearSum(int[][] x){
        int sum = 0;
        for(int i=0;i<x.length;i++){
            for(int j=0;j<x[i].length;j++){        
                sum += x[i][j];
            }    
        }
        return sum;
        }
        C:杨辉三角形
        public static void yangHui(int[][] x){
        for(int i=0;i<x.length;i++){
            for(int j=0;j<=i;j++){
                if((j==0)){
                    x[i][j] = 1;
                    System.out.print(x[i][j]+"	");
                }else if((i==x[i].length-1)&&(j==x[i].length-1)){
                    x[i][j] = 1;
                    System.out.print(x[i][j]+"	");
                }else{
                    x[i][j] = x[i-1][j-1]+x[i-1][j];
                    System.out.print(x[i][j]+"	");
                }
            }
            System.out.println();
        }
        }
2:两个思考题(理解)
    (1)Java中的参数传递问题
        class ArgsDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b); //a:10,b:20
        change(a,b);
        System.out.println("a:"+a+",b:"+b); //栈中的来自方法区的运算被释放    a:10,b:20

        int[] arr = {1,2,3,4,5}; 
        change(arr);
        System.out.println(arr[1]); //地址指向堆中的数据发生了改变    4
    }
    public static void change(int a,int b) { //a=10,b=20
        System.out.println("a:"+a+",b:"+b); //a:10,b:20
        a = b;    //a=20
        b = a + b; //b=40
        System.out.println("a:"+a+",b:"+b); //a:20,b:40
    }
    public static void change(int[] arr) { //arr={1,2,3,4,5};
        for(int x=0; x<arr.length; x++) {
            if(arr[x]%2==0) {
                arr[x]*=2;
            }
        }
        //arr={1,4,3,8,5};
    }
}
        Java中只有值传递。
        
        基本类型：形式参数的改变不影响实际参数
        引用类型：形式参数的改变直接影响实际参数
    (2)数据加密问题
        综合的小案例。//转化为倒序数组
import java.util.Scanner;
class MiBao2{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据：");
        int value = sc.nextInt();
        String result = jiaMi(value);
        System.out.println(result);
        
        }
        
    public static String jiaMi(int x){
        int[] arr = new int[8];
        int index = 0;
        while(x>0){
            arr[index] = x%10;
            x = x / 10;
            index++;
        }
        
        for(int i=0;i<index;i++){
            arr[i] += 5;
            arr[i] %= 10;
        }
        
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;
        
        String s = "";
        for(int i=0;i<index;i++){
            s += arr[i];
        }
        
        return s;        
    
    }
}
    
3:面向对象(掌握)
    (1)面向对象
        面向对象是基于面向过程的编程思想
        面向对象：强调的是对象，然后由对象去调用功能
    (2)面向对象的思想特点
        A:是一种更符合我们思考习惯的思想
        B:把复杂的事情简单化
        C:让我们从执行者变成了指挥者
        
        举例：
            买电脑
                面向过程（C语言）：我得了解电脑--了解我的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑
                面向对象：我知道我要买电脑--班长去给我买--班长就买回来了
            洗衣服
            做饭
            ...
            万事万物皆对象
    (3)把大象装进冰箱(理解)
        A:面向过程实现
            打开冰箱--装进冰箱--关闭冰箱门
            class Demo{
                public static void main(String[] args){
                    //System.out.println("打开冰箱");
                    //System.out.println("装进冰箱");
                    //System.out.println("关闭冰箱门");
                    open();
                    in();
                    close();
                }        
                public static void open(){
                    System.out.println("打开冰箱");
                }
                public static void in(){
                    System.out.println("装进冰箱");
                }
                public static void close(){
                    System.out.println("装进冰箱");                
                }
            }
        B:面向对象实现
            A：做这个事情有哪些类呢？（哪些对象）
            B：每个类有哪些东西
            C：类与类之间的关系是什么呢？（相互调用）
            把大象装进冰箱的分析?如何分析有哪些类呢？UML。名词提取法
            A：做这个事情有哪些类呢？
                大象，冰箱，Demo
            B：每个类有哪些东西
                大象：进去
                冰箱：开门，关门
                Demo：main方法
            C：类与类之间的关系是什么呢？
                Demo类中使用大象和冰箱类的功能
                
            class daxiang{
                public static void in(){
                    System.out.println("装进大象");
                }
            }
            class bingxiang{
                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:类与类的关系
    (4)类与对象
        面向对象的开发：就是不断的创建对象，使用对象，指挥对象做事情
        面向对象的设计：就是在管理和维护对象之间的关系
        面向对象的特征：封装（encapsulation），继承（inheritance），多态（polymorphism）
        
        A:现实世界的事物
            属性    事物的基本描述
            行为    事物的功能
        B:Java语言中最基本的单位是类。所以，我们要用类来体现事物
        C:类
            成员变量    事物属性
            成员方法    事物行为
        D:类：是一组相关的属性和行为的集合。是一个抽象的概念。
          对象：是该类事物的具体存在，是一个具体的实例。(对象)
          
          举例：
            学生：类
            班长：对象
    (5)类的定义及使用
        A:类的定义
            成员变量    定义格式和以前一样，就是位置不同，在类中，方法外。
            成员方法    定义格式和以前一样，就是去掉了static。
        B:使用类的内容
            a:创建对象? 格式
                类名 对象名 =  new 类名();
            b:如何使用成员变量和成员方法呢
                对象名.成员变量
                对象名.成员方法()
    (6)案例：
        A:学生类的定义和使用
        B:手机类的定义和使用
    (7)内存图
        A:一个对象的内存图
        B:二个对象的内存图
        C:三个对象的内存图
    (8)Java程序的开发，设计和特征
        A:开发：就是不断的创建对象，通过对象调用功能
        B:设计：就是管理和维护对象间的关系
        C:特征
            a:封装
            b:继承
            c:多态