上海传智播客JAVASE_day06学习笔记

《第六天总结》 张伦琦
《二维数组和面向对象》
1.二维数组    
    A.二维数组的定义
        格式：
        1.int [][]arr=new int[3][4];
        2.int [][]arr=new int[3][];
           arr[0]=new int[5];
           arr[1]=new int[6];
           arr[2]=new int[8];                   
        3.int [][]arr={{15,9,2,4,9},{2,4,9},{2,4,92,4,9}}
        理解：
        JAVA没有真正的二维数组，是数组的数组
        JAVA中的二维数组是不规则矩形
        二维数组中装的是一维数组
        一维数组中装的是元素

    B.二维数组的使用    
        class TwoDArray
    {
        public static void main(String[] args)
        {
        /*
        int [][] arr=new int[3][];
        int[] arr1={45,56,68};
        int[] arr2={52,78};
        int[] arr3={79};
        arr[0]=arr1;
        arr[1]=arr2;
        arr[2]=arr3;
        */
        //int[][] arr={{45,56,68},{52,78},{79}};
        //如果二维数组，没有一维数组，将报空指针异常
        //如果有二维数组和一维数组，但是数组没有具体的值，将按默认值处理。因为数组存放在堆内存中
        int[][] arr=new int[3][];
        arr[0]=new int[]{45,56,68};
        arr[1]=new int[]{52,78};
        arr[2]=new int[]{79};
        //System.out.println(arr);//[[I@7852e922
        //System.out.println(arr.length);//3代表有3行
        //System.out.println(arr[1].length);//2有两列
        int sum=0;
        //我如何能找到每一个一维数组
       for (int i=0;i<=arr.length-1;i++ ){
          //System.out.println( arr[i]);//每一个一维数组
          //对找到的没一个一维数组进行遍历
          for (int j=0;j<=arr[i].length-1 ;j++ ){
              System.out.println(arr[i][j]);//每一个元素
              sum=sum+arr[i][j];
          }
        }
       System.out.println(sum);
        }
    }

2.面向过程和面向对象    
    A.面向过程
    面向过程的：
        1.是以过程为中心
        2.自己完成每一个过程。
        3.正确的组织所有的过程。
    面向过程的思想特点
        1.以方法为中心。以办事情所需要的动作、行为和过程为中心。
        2.自己编写相关方法。方法定义。
        3.自己组织相关方法。方法调用。

    B.面向对象
    面向对象的：
                1.事情有多少相关的对象（object）
        2.这些对象的关系是什么。
        3.描述好每一个相关的对象。（每个对象要做的事情说请清楚）
      面向对象的思想特点
        1.面向对象是相对面向过程而言的.(面向过程早，面向对象晚)
        2.面向对象是基于面向过程的。
        3.面向对象和面向过程都是一种思想。
          面向过程强调的是行为、动作、功能、方法。
          面向对象强调的是对象以及对象之间的关系。
        4.面向对象将人们从功能的实现者，转变成对象以及对象具有的功能的指挥者。
        5.是一种更符合人们思考习惯的思想，可以将复杂的事情简单化
        6.将程序员从执行者转换成了指挥者
     如何设计面向对象的程序
            写面向对象的程序的时候
            1.找出程序牵涉到的对象。
            2.如果存在相关的对象就直接拿来使用。
            3.如果不存在相关的对象就创建对象再使用。
     面向对象的设计，开发和特性
        1.面向对象的设计：其实就是设计系统相关的对象以及对象之间的关系。
                          管理和维护对象之间的关系。
        2.面向对象的开发：其实就是不断的创建对象，使用对象，指挥对象做事情。
        3.面向对象的特性：封装(encapsulation)继承(inheritance)多态(polymorphism)

    
3.类和对象    
    A.类和对象的自然语言描述
        人：抽象的东西：类描述，类别，类型，种类，可有无数个对象
        属性，数据，静态状态： 姓名 身高 年龄 体重 性别
        行为，功能，动态状态： 吃饭  喝水  睡觉 说话
    张三这个人（具体的东西）对象
           属性：
           姓名 张三
           身高 180
           年龄 20
           体重 156
           性别 男
       行为：吃饭  喝水  睡觉 说话

    B.类和对象的Java语言描述
            /*
        学生：抽象的，类,class
        属性：学号 性别 姓名  年龄
        行为：吃饭 学习 玩游戏

        王五这个学生：具体的对象
        属性：
            学号 wd001
            性别 男
            姓名 王五
            年龄 18
        行为：
            吃饭 学习 玩游戏
        赵六这个学生：具体的对象（实例）
        属性：
            学号 wd002
            性别 女
            姓名 赵六
            年龄 18
        行为：
            吃饭 学习 玩游戏


        1.创建类，不能直接工作，因为它是抽象的
        2.创建对象，可以直接工作，因为它是具体的
            Student stu1=new Student();
        3.使用对象
            A.对象的属性
            属性赋值：stu1.stuId="wd001";
            属性取值： Sop(stu1.stuId);
            B.对象的方法
            方法调用：stu1.playGame("英雄联盟");
        */
        class Student{
             //属性(数据，变量)：学号 性别 姓名  年龄  体重
             String  stuId;
             char  stuSex;
             String  stuName;
             int stuAge;
             double stuWeight;
             //方法：吃饭 学习 玩游戏
             public void eat(String caiMing){
                 System.out.println("学生吃"+caiMing);
             }
             public void study(String XueKeMing){
                 System.out.println("学生学习"+XueKeMing);
             }
             public void playGame(String gameName){
                 System.out.println("学生玩"+gameName);
             }
        }



        /*
        //测试类
        class StudentDemo
        {
            public static void main(String[] args)
            {  
            //Student stu1对象的引用在栈里，new Student()实体在堆里
                //Student stu1=new Student();//创建一个学生对象
                Student stu1;//创建一个学生对象
                //使用对象(属性)
            System.out.println(stu1.stuId);//null
            System.out.println(stu1.stuSex);//' '
            System.out.println(stu1.stuName);//null
            System.out.println(stu1.stuAge);//0

                //使用对象（属性赋值）
                stu1.stuId="wd001";
                stu1.stuSex='男';
                stu1.stuName="王五";
                stu1.stuAge=18;

            //使用对象(属性取值)
                System.out.println("********************************");
            System.out.println(stu1.stuId);//wd001
            System.out.println(stu1.stuSex);//男
            System.out.println(stu1.stuName);//王五
            System.out.println(stu1.stuAge);//18

                //使用对象(方法)
                stu1.eat("水煮白菜");
                stu1.study("java");
                stu1.playGame("英雄联盟");

                
            }
        }
        */



        class StudentDemo
        {
            public static void main(String[] args)
            {
                /*
                Student stu1=new Student();
                stu1.stuName="张三";
                stu1.stuName="李四";
                System.out.println(stu1.stuName);//李四
                */

                /*
                Student stu1=new Student();
                stu1.stuName="张三";
                Student stu2=stu1;
                stu2.stuName="李四";
                System.out.println(stu1.stuName);//李四
                */
                /*
                Student stu1=new Student();
                stu1.stuName="张三";
                Student stu2=new Student();
                stu2=stu1;
                stu2.stuName="李四";
                System.out.println(stu1.stuName);//李四
                */

                

            }
        }
    C.类和对象的练习    
        /*
       电话：抽象的，用类来描述
       属性：价格 品牌 颜色 尺寸
       行为：打电话 发信息 玩游戏
       1.描述类
       2.创建对象
       3.使用对象
          属性
              方法

       对象的成员
            1.成员变量：和对象相关的变量，定义在类中。
            2.成员方法：和对象相关的方法，定义在类中。



       类和对象的关系
        1.类  : 是抽象的事物，是对象归类产生的概念，可以有无数个具体的对象。
        2.对象：是具体的事物，是类的一个具体的实例。
        3.对象是由属性和行为组成的。
           属性是对事物的数据的描述。成员变量（字段，域，属性：field）
           行为是对事物的功能的描述。成员方法(成员函数，功能，行为：method)

       引用和实体的关系
          1.对象的实体相当于电视机；堆中。
          2.对象的引用相当于遥控器；栈中。
          3.对象的实体可以有多个引用，相当于一个电视机有多个遥控器。
          4.对象的实体可以没有引用，相当于电视机没有遥控器。
          5.分析时要明确引用指向的实体，明确哪个遥控器控制着哪个电视机。

    */
    class Phone{
        // fields 属性：价格 品牌 颜色 尺寸
        double price=2500.00;
        String brand;
        String color;
        double size;
        // methods 行为：打电话 发信息 玩游戏
        public void call(String name){
            System.out.println("打电话给"+name);
        }
        public void sendMessage(String name){
            System.out.println("发信息给"+name);
        }
        public void playGame(String gameName){
            System.out.println("玩游戏"+gameName);
        }
    }
    class PhoneDemo {
        public static void usePhone(Phone ph){//ph=0x11
            //使用对象(属性：赋值)
            ph.price=2500.00;
            ph.brand="IPHONE4S";
            ph.color="白色";
            ph.size=3.5;
            //使用对象(属性：取值)
            System.out.println(ph.price);
            System.out.println(ph.brand);
            System.out.println(ph.color);
            System.out.println(ph.size);
        //使用对象的方法
            ph.call("范冰冰");
            ph.sendMessage("黄晓明");
            ph.playGame("找你妹");
        }
        public static void main(String[] args) {
            //创建对象
            Phone ph=new Phone();
            usePhone(ph);
            System.out.println(ph.price);
            System.out.println(ph.brand);
            System.out.println(ph.color);
            System.out.println(ph.size);
        }
    }

4.局部变量和成员变量
    成员变量：定义在类中和对象相关的变量；
    局部变量：定义在方法中和方法相关的变量

     成员变量和局部变量的区别?
        区别一：定义位置不同。
            成员变量定义在类中和对象相关。
            局部变量定义在方法中以及语句里，和方法相关。

        区别二：存储位置不同。
            成员变量存储在堆内存的对象中。
            局部变量存储在栈内存的方法中。
            
        区别三：存生命周期不同。
            成员变量随着对象的创建而创建，随着对象的消失而消失。
            局部变量随着的方法的进栈而创建，随着方法的弹栈而消失。

        区别四：初始化不同。
            成员变量因为在堆内存中，所以有默认初始化值。
            局部变量因为在栈内存中，所以没有默认初始值，必须初始化后才可以使用。

    */
    class Phone{
        //成员变量
        int price;
        //成员方法
        void show(){
            //局部变量
            int price;
            System.out.println(price);
        }
    }
    class  BianLiang{
        public static void main(String[] args)
        {
            Phone ph=new Phone();
            //System.out.println(ph);//Phone@7852e922
            System.out.println(ph.price);
            ph.show();
        }
    }

5.匿名对象

    /*
        匿名对象：对象没有名称，对象没有引用
        应用场景：
           1.对象只使用一次，不需要给对象起名称。
           2.匿名对象作为方法调用实参
    */
    class Phone{
        void close(){
            System.out.println("电话关机");
        }
        void open(){
            System.out.println("电话开机");
        }
    }
    class NiMingDemo {
        public static void usePhone(Phone ph) {
            ph.close();
        }
        public static void main(String[] args) {  
            //Phone ph=new Phone();//有名对象
            //new Phone();//匿名对象
            //有名对象可以用无数次
            Phone ph=new Phone();
            ph.close();
            ph.open();
            ph.close();
            ph.open();
        //场景一、匿名对象只能使用一次。对象只使用一次，不需要给对象起名称。
            new Phone().close();
            //场景二、匿名对象作为方法调用实参
            usePhone(new Phone());
            
        }
    }