Day06 --面向对象

 a.
    面向对象：
        思想：
            * 首先先要了解什么是面向过程，面向过程就是第一步该怎么做，第一步该怎么做，强调的是过程（执行者）。
            * 而面向对象是调用对象来做事情，强调是对象（调用者）。
            * 面向对象是通过面向过程来推演过来的，c语言就是面向过程。java是面向对象。
             * 对象即方法。
             
        举例：
            买煎饼
                面向过程：
                    1）学摊煎饼的技术。
                    2）买材料：准备面，油，鸡蛋， 水。
                    3）自己做。    
                    4）吃。
                    5）收拾垃圾。
    
                面向对象：
                    1）直接找会摊煎饼的人。（因为具备这样功能的方法）
                    2）给钱。（调用）
                    3）吃。（出结果）
            洗衣服
                面向过程：
                    1）准备：水，搓衣板，洗衣服。
                    2）洗衣服
                    3）收衣服。
    
                面向对象：
                    1）将衣服放入洗衣机（因为具备这样功能的方法）。
                    2）洗。（调用）
                    3）收衣服。（出结果）

【面向对象，强调的是对象，面向过程，强调的是事件的过程。】
​    
    面向对象特点：
        1） 是一种更符合思考习惯的一种思想。
        2） 可将复杂问题简单化。（方法变复杂，但是可多次使用）
        3） 由原来的执行者（面向过程）变成现在的调用者（面向对象）。
        4） 角色发生了改变。
    p.s.
    面向对象的特点：
        是一种符号人民思考习惯的思想，可以将问题简单化，将程序员由原来的执行者变成了现在的调用者，
    完成需求时：
        1）先要去找具有所需功能的对象来用。
        2）如果该对象不存在，那么久创建一个具有该需求功能的对象。
        这样就可以简化开发和提高复用性。


    面向对象开发：
        就是不断的创建对象，使用对象，指挥对象来做事情。


【java原则：
    简化说：有对象，就调用对象，没有对象，就直接创建对象。 
    复杂说：有该功能的对象就直接对象，没有该功能的对象就创建具备该功能的对象。
】

    面向对象的设计：
        就是在管理和维护对象之间关系的这么一个过程。【【值得思考】】
    
    面向对象特征：
        封装：将功能的过程封装在一个方法中。
        继承：在子父类中，继承功能的这么一个过程。
        多态：表示方法具备多种形态，即多种使用规则方式。


b.
    学编程的作用？
        将生活中的事物，用计算机的语言给表述出来。不止java语言能完成，如c等也可以。
            
    如何描述世间的事物？
        属性： 就是该事物描述的信息。 （事物身上的名词）
        行为： 就是该事物能做到什么事情。 （事物身上的动词）
        
        比如：
            描述一个人。
                属性：姓名，性别，身高等。
                行为：让他能够做什么事情，如：睡，跳，吃饭等。
    
    java中最基本的单位是类，用class来描述事物。
         * 成员变量     就是事物的属性。即年龄，性别。
        * 成员方法    就是事物的方法。即看书，敲代码。     
            
    创建类就是在创建类的成员，即属性和方法。
        * 成员变量： 和以前定义变量是一样的，只不过是位置发生了变化，成员方法在类中，方法外。
        * 成员方法： 也和以前定义方法是一样的，只不过将static给去掉了。 因为static是静态的意思，后面遇到静态再说 




变量：

    局部变量：方法声明上或方法内。
    如：
        public static void method(int a,int b){ //a,b是局部变量。
            int c = 0; //c是局部变量。
        }
    
    成员变量：类中，方法外。
    如：
        class Test{
            int num = 0;// num是成员变量。
            main(){
                
            }
        }

方法：

    普通方法：
        public static void method(){ //主要用于有主方法的类，如果在一个类有主[static]方法，并列的其他普通方法必须要有static来修饰。
    
        }
    
    成员方法：
        publi void method(){ //主要用于没有主方法的类。
    
        }


    类和对象的概念：
        类： 
         * 简易说：
             *  是一种相关属性和行为的集合。        
         * 自己理解：
             * 是其中包含类似的属性信息 和 方法 的组合。
    
        对象：
           * 简易说：
               * 是事物的具体的一种体现。
           * 自己理解：
               * 就是完成某种特定功能的一种封装过程的方法。
    p.s.
    类和对象之间的关系
        使用计算机语言就是不断的描述现实生活中的事物。
        java中描述事物通过类的形式来体现，类是具体事物的抽象，概念上的定义。
        对象即是该类事物实实在在的个体。

定义类其实就是定义类的成员，即成员变量和成员方法。

    p.s.
    成员变量和局部变量的区别？
        成员变量：
            1） 定义在类中方法外，在整个类中都可以被访问。
            2） 成员变量使随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。
            3） 成员变量有默认初始化值。
    
        局部变量：
            1） 局部变量只是定义在局部范围中，如:方法中，语句内，所属的区域也是有效的。
            2） 局部变量在栈内存中，作用的范围结束，变量空间会自动释放。
            3） 局部变量没有默认初始化值。 
    
    p.s.
        匿名对象
            匿名对象是对象的简化形式。
        匿名对象使用的两种情况：
            1） 当对对象方法仅仅调用一次的时候。
            2） 匿名对象可以作为实际参数进行传递。

例：
    类： 学生
            包含：
                * 属性：身高，性别 （名词即属性）
                * 行为：吃饭，睡觉 （动词即方法） 
        
    对象：
            包含：
                * 对象，方法。
                * 学生就是对象，即这个学生能干什么，即方法。    


​        
【即类是抽象的，统称。 对象是具体的，明确的。】
​    
      类： 车类，水果类，都是抽象的。即某种特定的功能的封装。表现在分层开发，分模块开发。
    对象： 宝马对象，奔驰对象。 是该类的具体体现，即明确功能的具体体现。
    
    什么是类，什么是对象？
        类：类是一种抽象的概念，用于描述某种事物的统称。是一组相关属性和行为的集合
            属性：用来描述事物的信息
            行为：具体让事物做什么事情
        
        对象：该事物的具体体现
        
    如何使用类中的成员变量和成员方法？
        成员变量：是事物的属性。看其在类中的位置使用。用this来区分成员变量。  
        成员方法：是事物的行为。出现在没有主方法中的。即该方法没有static修饰。

​        

c.
    学生类的定义
        // 定义学生类
        class Student {
            //属性
             String name;
             int age;
             String sex;
            
            public void study(){ //定义学习的方法
                System.out.println("学生："+name+" 学习");
            }
        
            public void sleep(){ //定义睡觉的方法
                System.out.println("学生："+name+" 睡觉");
            }


    学生类怎么使用？
        a.  
            文件名的问题：
                在一个java文件中，写两个类。即一个基本类（没有main主方法的类）。 和 一个测试类（含有main主方法的类）。
            建议：
                文件名称和测试类名称一致。
        b. 
            怎么使用对象？
                概述：
                    创建对象并使用；
                格式：
                     标准：
                        类名  对象名 = new 类名();
                    自己理解：    
                        基本类名 对象名 = new 基本类名();        
            
            对象名的写法
                即基本类中的方法名，就是合法的标识符，如果是一个单词，所有字母小写，如果是多个单词，从第二个单词开始首字母大写。
    
        c.    
            怎么使用成员变量名？
                对象名.成员变量名
    
        d.
            如何使用成员方法？
                对象名.方法名()


例子：
    class Demo2_Phone {
        public static void main(String[] args) {
            Phone p = new Phone();
            p.brand="华为荣耀";
            p.price=2999;
        //方式一 赋值后调用。
            p.call();
            
        //方式二 直接传入实参。    
            p.sendMessage("苹果8Plus",7999);
    
        //方式三 键盘录入调用。
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入品牌：");
            String brand = sc.next();
            System.out.println("请输入价格：");
            int price = sc.nextInt();
            p.playGame(brand,price);
        }
    }
    
    /*
        * 模仿学生类，让学生自己完成
        * 属性:品牌(brand)价格(price)
        * 行为:打电话(call),发信息(sendMessage)玩游戏(playGame)
    */        
    
    class Phone {
        String brand;   //属性:品牌(brand)
        int price;        //属性:价格(price)
    
    //打电话的方法
        public void call(){ 
            System.out.println("品牌："+brand+" 价格："+price+" 打电话(call) ");
        }
    
    //发信息的方法
        public void sendMessage(String brand, int price){  
            System.out.println("品牌："+brand+" 价格："+price+" 发信息(sendMessage) ");
        }
        
    //玩游戏的方法
        public void playGame(String brand, int price){  
            System.out.println("品牌："+brand+" 价格："+price+" 玩游戏(playGame) ");
        }    
            
    内存空间分布：
        栈：成员方法在栈内存中。 
        堆：成员属性也是对象，对象都在堆内存中。
     方法区：（代码仓库） 
        1）一开始.java源文件,编译后变成.class文件，在硬盘中。
        2）当运行后的.class文件进入内存中。【所以说买电脑时，内存空间的大小和读写速度也是很重要的。】
        3）位置到了方法区中去存储。


例
一个对象的内存图
        class Demo3_Animal {
            public static void main(String[] args) {    
                Animal an = new Animal();
                an.color="白色";
                an.age=5;
        
                an.play();
                an.sleep();
            }
        }    
        
        class Animal {
        // 动物的属性
            String color;
            int age;
        
        // 动物的行为
            public void play(){
                System.out.println("动物："+color+" 年龄："+age+" 玩游戏 ");
            }
                    
        // 动物的行为
            public void sleep(){
                System.out.println("动物："+color+" 年龄："+age+" 玩游戏 ");
            }
        }

【对象在内存中的执行流程】
        1） 一开始Demo3_Animal.java源文件,编译后变成Demo3_Animal.class文件，在硬盘中。
        2） 当运行后的Demo3_Animal.class文件进入内存中。【所以说买电脑时，内存空间的大小和读写速度也是很重要的。】
        3） Demo3_Animal.class到了方法区中去存储。
        4） Demo1_Animal.class进入内存中的方法区，该.class文件中有main。
        5） 因为Demo1_Animal.class中有main，所以虚拟机帮我们调用主方法main，方法都是进栈的，所以调用main方法，就会进入栈，以栈针的形式压到最低部。
        6） Animal an的Animal也是个.java文件，编译后.class文件，所以也先进入方法区中。
        7） Animal an的实例引用也会进入栈内存的main主方法中。 
        8） new Animal(); new的对象都会在堆内存中，里面包含了成员变量（成员变量也属于对象，对象都进堆内存）。先默认初始化值，然后再赋值。
        9） 然后将堆内存中的new对象的地址值给了栈内存Animal an，让其记录住地址值，就可以通过该地址值找到栈内存中的一样的地址值说代表的对象。
       10） an.play();成员方法，方法都进入栈内存中，该方法中an隐藏了this,this表示谁使用我，我就代表谁。因为an中记录有地址值，所以an的地址值同样指向堆内存        中new的地址值。所以就能得到其变量的具体值，输出打印出来后。
       11） an.play();弹栈。
       12） an.sleep();成员方法，方法都进入栈内存中，该方法中an隐藏了this,this表示谁使用我，我就代表谁。因为an中记录有地址值，所以an的地址值也指向堆内存        中，所对应的new的地址值。打印输出结果后。
       13） an.sleep()弹栈。
       14） 程序结束。


        an = null; //null将原先的地址值给覆盖掉了。
        an.play(); //an中记录了null,所以就会出现空指针异常。
        所以说现在堆内存中的new Animail()就变成了垃圾，根据堆内存中对于 没有任何引用（地址值）指向该对象的处理是这样的：
        当该对象变成了垃圾（即栈内存中的指向找不到该对象），java中有完善了垃圾回收机制，会在不定时的情况下将其继续回收处理。

程序每次使用完后都要写an=null。吗？
        不用，因为最终主方法在栈内存中被压入栈低被弹栈后，该栈内存中的所有对象的指向就都变成了null, 即堆内存中的原先对应的对象，就都变成了垃圾，java就会做出不定时了垃圾回收处理。所以不用每次使用完后都将对象an=null。

        【也是就是说栈内存中如果没有在堆内存中有相应的指向，栈内存中的对象就变成了垃圾， java会不定时的清理垃圾。】

d.
局部变量和成员变量的区别？ 4个区别
        * 在类（作用域）中的位置不同
            成员变量： 在类中，方法外。
            局部变量： 在方法声明上或方法中。
    
        * 在内存（范围）中的位置不同
            成员变量： 在堆内存中（因为成员变量也是对象，对象都进入堆内存中）
            局部变量： 在栈内存中（因为局部变量是方法，方法都进入栈内存中）
    
        * 生命周期不同
            成员变量： 随着对象的创建而存在，随着对象的消失而消失。
            局部变量： 随着方法的调用（进栈）而存在，随着方法的调用完毕（弹栈）而消失。    
    
        * 初始化值不同
            成员变量： 有默认初始化值。
                        整数：byte,short,int 都是0，
                        整数：long是0L
                        浮点：float是0F,double是0.0D
                        char：空字符，'\u0000' 
                        boolean：false
                        引用数据类型都是：null
    
            局部变量： 没有默认初始化值，必须先赋值，才能使用。
        
    注意事项：
        * 局部变量和成员变量的名字可以一样，那程序怎么区别呢？ java中采用的是就近原则。 谁先在被调用前，就使用谁。
        为什么可以名字相同？因为局部和成员所在的内存中的位置不同，局部在栈，成员在堆。
        
        * 基本数据类型的【变量】都有哪些：byte,short,int,long,float,double,char,double 
        * 引用数据类型的【变量】都有哪些：字符串，数组，类，接口，枚举
        
    自己理解：
        * 【基本数据类型:变量名直接指向具体的数值。
        *  引用数据类型: 变量名指向存储在堆内存中的数据对象的【内存地址】,即变量名指向数据对象的哈希Code地址值。
        *  即 类、接口、数组、枚举和字符串。这种引用数据类型的变量并不包含类型的实例（new出来的对象），而只是包含对实例的引用(地址值)。
            *  如：
                *  1）Car c1中的c1就是实例的引用，Car c1 = new Car();  new Car()就是堆内存中具体的地址值。 
                   2）int[] arr 中的arr就是实例的引用 int[] arr = new int[]{4,5,6,7,8} 中的new出来的对象就是堆内存中具  体的地址值。
        * 】


e.
    当方法的形式参数是一个类名（对象）的使用该怎么调用？
    如：public static void print(Student s);
        如果是这样的时候，就必须使用该类的对象，即 print(new Student())；

例子 
    名字：Demo1_当形式参数是一个类时该如何使用
    地址：G:\CSDN_Android_\Code\day06\04_匿名对象\Demo1_当形式参数是一个类时该如何使用.java
    地址中有具体说明    
    
    class Demo1_当形式参数是一个类时该如何使用 {
        public static void main(String[] args) {
            Person p = new Person(); //先创建对象
            speak(p);
        }
    
            // 必须是类的实例，要先创建对象    
            public static void speak(Person p){ //引用数据类型 给的是new实例的地址值
                p.name="你好啊";
                p.age=9;
                p.print();
            } 
    
            int a =9;
            public static void speak(int a){ //基本数据类型 可以直接赋值进行实参调用。
                System.out.println(a);
            }
            
            //public static void speak(Person s){ 报错 只能是类的实例
            //} 
                    
        /*
            // 不能这样写，因为方法在栈内存中，而new Person()在堆内存中，两者没有直接联系的通道，即地址值。只能通过实例的引用调用。如上面的例子。
            public static void speak2(new Person()){
                new Person().name="阿麦";
                new Person().age = 4;
                new Person().print();
            }
        */
    }
    
    class Person {
        String name;
        int age;
    
        public void print(){
            System.out.println(name+" "+age);
        }
    }


f.
    匿名对象
        概念：
            就是没有名字的对象。
            对象的名字？ 是实例的引用，如下：
            Person p = new Person()； 没有了Person p，也没有了引用p。只有 new Person();
            也可以说没有被赋予地址值的对象。
    
        使用场景：
            主要用于调用方法，也可用于调用成员变量。 且只使用一次的时候。
        
        好处呢？
            节省代码。
        
        坏处
            当对象需要被多次使用时，不适合匿名调用，因为匿名调用完后，就变成了垃圾，等着垃圾回收处理呢、
        
    【注意】
        匿名对象可以被作为实际参数传递。
    
    什么是匿名对象？什么时候使用？
        匿名内部类：
                a.是一种没有名字的类，就是没有该对象的引用。
        
        如何使用：直接 new 对象().方法;
        
        什么时候使用：当程序只需要调用该方法一次的时候，使用。

g.
    封装
        隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
    
    好处：
        * 隐藏其实现细节，对外提供公共的访问方法。
        * 提高代码的复用性。
        * 提高安全性。
    
    原则：
        * 不需要对外提供的内容都隐藏起来。
        * 使用private关键字，来修饰属性，使其私有化，并提供公共的访问方法getXXX() 和 setXXX(),供其他类调用。
        
    体现：
        封装使用的关键修饰符：private，被封装的属性只能本类使用，如果其他类想使用，必须提供get()，set()方法。
    
    private关键字：
        * 他是一个权限修饰符。
        * 可以修饰成员变量和成员方法。
        * 被其修饰的成员，只能在本类中访问，如果其他类想访问，需要对外提供对应的公共（public）get()和set()方法即可。
    
    private就是帮助我们封装的，只是封装的一种体现形式，不能说封装就是私有。
    
        setXXX(); 返回值类型void，必须有形参。
        getXXX(); 返回值不能是void, 必须有return，没有参数。

​    

h.
    this关键字
        概念
            * 代表当前对象的引用，即谁来调用我，我就代表谁。
                * 比如我来使用this, this就能代表我的权力做事情。
                * 例子：皇帝将尚方宝剑给了我，我现在说的话，就是代表皇上的话。
    
        自己理解
            * this代表当前对象的引用。所以说当局部变量和成员变量的名称一致时，一定要用this来区分，不然结*果都是该数据类型的默认值。一般get和set方法的局部和成员变量名都一致，所以必须加this。
            * 同样getXXX()方法也是获取成员变量的，你不加this，系统会给你加上，但set方法中是不会给你自动加this的。
        
        作用
            用来区分成员变量和局部变量的重名问题。    
        
    使用场景
        用于方法中访问对象的其他成员。在方法中，表示访问成员变量:即this.name = name。this.name是成员变量。右边的name是局部变量。
        
    this是什么？    
        this代表当前对象的引用。
        用于区分成员变量和局部变量的重名问题。主要给成员变量用的。
        如果程序中出现相同名字的成员变量和局部变量，采用就近原则，而且来使用this关键字来区分成员属性和成员方法。
    
        有set和get方法的类，叫javaBean类，或实体类。

例子：
    public void setName(String name){
        this.name = name; //this.name是成员变量 this是用来当局部和成员变量名字相同时，来修饰成员变量用的。
    }
    
    public String getName(){
    
        return this.brand; //同样getXXX()方法也是获取成员变量的，你不加this，系统会给你加上，但set方法中是不会给你自动加this的。
    }
    
    public void setAge(int age){
        this.age = age; //this.age是成员变量 this是用来当局部和成员变量名字相同时，来修饰成员变量用的。
    }
    
    public int setAge(){
    
        return this.brand; //同样getXXX()方法也是获取成员变量的，你不加this，系统会给你加上，但set方法中是不会给你自动加this的。
    }
    
    Java语言最基本的单位是：
        JAVA中的基本单位是类（class）
    计算机能直接识别的进制是：
            计算机能直接识别二进制
    计算机最小的存储单位是：
            最小的存储单位是：字节