JAVA SE — Day 09

###目 录

第1章 面向对象
1.1 面向对象及面向过程
1.2 面向对象举例
1.3 面向对象思维方式的优势
第2章 类与对象
2.1 对象在需求中的应用
2.2 对象在代码中的体现
2.3 对象的内存图解
2.4 类和对象的区别
2.5 局部变量与成员变量的区别
2.6 基本类型和引用类型
第3章 封装
3.1 封装概述
3.2 封装举例
3.3 私有private
3.4 this 关键字
3.4.1 局部变量与成员变量的区别
3.4.2 对象内存解释
3.4.3 this的应用
第4章 综合案例 随机点名案例重构

第1章 面向对象

1.1 面向对象及面向过程

● 面向过程与面向对象都是我们编程中，编写程序的一种思维方式
（a）面向过程的程序设计方式，是遇到一件事时，思考“我该怎么做”，然后一步步实现的过程。
（b）面向对象的程序设计方式，是遇到一件事时，思考“我该让谁来做”，然后那个“谁”就是对象，他要怎么做这件事是他自己的事，反正最后一群对象合力能把事就好就行了。

1.2 面向对象举例

●买电脑（组装机）
（a）面向过程的解决方法：需要到网上查询每个硬件的参数和报价，到电脑城询价然后进行比较，之后综合各方面决定在哪一家组装，并且监督过程防止被换件，安装相应的系统，最后抱着电脑回家。如果不懂行的话很可能买到高价的残次品。
（b）找一个懂电脑的人帮我完成一系列步骤，最后抱着电脑到我家就行了。

1.3 面向对象思维方式的优势

（a）面向对象思维方式是一种更符合人们思考习惯的思想
（b）面向过程思维方式中更多的体现的是执行者（自己做事情），面向对象中更多的体现是指挥者（指挥对象做事情）。
（c）面向对象思维方式将复杂的问题简单化。

第2章 类与对象

2.1 对象在需求中的应用

●如何使用面向对象去解决问题
以把大象装进冰箱为例：
需求：把大象装进冰箱
对象：大象、冰箱
步骤：打开冰箱 、装大象，关冰箱
分析发现冰箱对象具备功能如下：冰箱打开、冰箱存储、冰箱关闭

//通过伪代码描述大象和冰箱:
        * 描述大象：
            class 大象
            {
            }
        * 描述冰箱
            class冰箱
            {
                void 打开(){}
                void 存储(大象){}
                void 关闭(){}
            }

使用对象：
* 1、创建冰箱的对象
冰箱 bx = new 冰箱();
* 2、调用冰箱的功能
对象.功能()；
bx.打开();
bx.存储(new 大象());
bx.关闭();

2.2 对象在代码中的体现

●通过JAVA代码描述小汽车

package cn.itcast.demo01;
/*
 * 用类的思想，描述现实中的小汽车
 * 属性：颜色、轮胎个数    变量定义
 * 功能：跑      方法
 * 
 * 属性又叫做成员变量
 * 方法又叫成员方法
 */
public class Car {
  //定义Car的属性
    String color;
    int count;
  //定义Car的功能
    public void  run () {
        System.out.println("小汽车在跑..."+ color+"..."+count );
    }
}

package cn.itcast.demo01;
/*
 * 测试，自定义的类Car
 * 创建Car类的变量
 * 用变量调用属性，即成员变量
 * 用变量调用功能，即成员方法
 */
public class CarTest {

    public static void main(String[] args) {
        //创建出Car类的变量，
        Car c = new Car();
        //对象，调用类中的属性和方法
        c.color ="无色";
        c.count= 5;

        c.run();
    }
}

2.3 对象的内存图解

2.4 类和对象的区别

1)类和对象的关系
* 类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。类中可以定义事物的属性和功能，用于描述多个对象的共同特征，相当于一个模具；对象是通过new关键字创建出来的，根据类创建出来，一个类可以对应多个对象，且每个对象彼此不同。
2) 举例
* 可以将玩具模型看作是一个类，将一个个玩具看作对象，从玩具模型和玩具之间的关系便可以看出类与对象之间的关系

2.5 局部变量与成员变量的区别

区别一：定义的位置不同
    * 定义在类中的变量是成员变量
    * 定义在方法中或者{}语句里面的变量是局部变量

区别二：作用域不同
    *成员变量，作用范围是整个类
    *局部变量，作用于方法内、语句内

区别三：默认值不同
    * 成员变量因为在堆内存中，所有默认的初始化值
    * 局部变量没有默认的初始化值，必须手动的给其赋值才可以使用，不赋值不可用。

区别四：在内存中的位置不同
    * 成员变量，跟随对象进入堆内存存储
    * 局部变量，跟随自己的方法进入栈内存

区别五：生命周期不同
    * 成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
    * 局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失

2.6 基本类型和引用类型

1）基本类型

public class TestPerson {
      public static void main(String[] args) {
        int a =1;
        function(a);
        System.out.println(a);
    }
/*
 * 定义方法，参数是基本数据类型      
 */
      public static void function(int a) {
          a+=5;
      }

}

图解：

2）引用类型

public class TestPerson {
      public static void main(String[] args) {
        Person p = new Person ();
        p.name="张三";
        function (p) ;
        System.out.println(p.name);
    }
/*
 * 定义方法，参数是引用数据类型      
 */
      public static void function(Person p) {
         p.name= "李四";

      }

}

图解：

3）结论

    * 对于基本类型形式参数改变不会影响到实际参数
    * 对于引用类型形式参数改变会影响到实际参数 

第3章 封装

3.1 封装概述

1）面向对象三大特征
* 封装、继承、多态
2）封装表现
* 1、方法就是一个最基本封装体
* 2、类其实也是一个封装体
3）封装的好处
* 1、提高了代码的复用性
* 2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念
* 3、提高了安全性

3.2 封装举例

1）封装的生活中的举例
机箱：
一台电脑，它是由CPU、主板、显卡、内存、硬盘、电源等部件，将这些部件组装在一起就可以使用电脑了，但是如果这些部件都散落在外面，就造成不安全因素，于是，使用机箱壳子，把这些部件都装在里面，并在机箱壳上留下一些插口等，以便调用。
总结：机箱其实就是隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。
2）总结
机箱其实就是隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式

3.3 私有private

1）private概述
* private可以修饰成员内容包括成员方法和成员变量
* 被private修饰的内容不能在其他类访问
2）代码示例：
标准代码：

/*
 * 描述现实生活中的人
 * 属性：姓名  年龄
 * 功能：说话
 * 
 * 安全问题：age中可能出现负数或过大数字
 * 负数不会影响程序运行，但违反生活实际情况
 * 
 * 改善安全问题的方法：让外边的类，不允许直接调用我的成员变量
 * 使用新的关键字   private 私有 属于成员修饰符 ，不能修饰局部变量！
   被private修饰的成员，只能在自己的类中被使用

   对私有变量，提供公共的访问方式：方法
 *
 */
public class Person {
     //人的姓名，成员变量
    String name ;
     //人的年龄，成员变量
    private int age;

    //变量age被私有，提供方法，让外边的类使用
    //定义方法，对age变量进行赋值(要求方法名字必须以set开头)
    public void setAge(int a) {

        //可以对变量a禁行范围限制
        if(a<0||a>130) {
            age = 20; 
        }else {
            age = a;
        }
    }


    //定义方法，对变量age获取值使用，方法名字get
    public int getAge() {
        return age;
    }


    //定义人说话的功能，方法中要求说出自己的姓名和年龄
    public void speak() {
        System.out.println(name+"..."+age);
    }


}

测试标准代码：

/*
 * 定义好的Person类进行测试
 * 创建对象，对象调用属性和方法
 */
public class PersonTest {
      public static void main(String[] args) {
        //创建Person类的对象
        Person p = new Person ();
        //p.age= 20;被私有 不能直接使用，只能调用set方法赋值
        p.setAge(70);
        p.name="张三";

        //调用类中的方法
        p.speak();

        //输出成员变量age值，必须使用get方法
        System.out.println(p.getAge());
    }


}

●私有private只是封装的一种表现形式；由于私有以后外类不能访问，所以必须使用setXXX和getXXX的方法提供公共访问方式。
3）以后描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。
标准代码：

/*
 * 描述现实生活中的人
 * 属性：姓名  年龄
 * 功能：说话
 * 
 * 私有所有的属性（成员变量），必须写对应的set、get方法
 * 凡是自定义类，自定义成员变量，应该私有化，并提供set和get方法
 *
 */
public class Person {

    private String name ;  
    private int age;

    //set方法，对name和age变量进行赋值  
    public void setName(String n) {

            name = n;
    }
    public void setAge(int a) {

            age = a;
    }   


    //get方法，对变量age、name获取值 
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    //定义人说话的功能，方法中要求说出自己的姓名和年龄
    public void speak() {
        System.out.println(name+"..."+age);
    }   
}

测试标准代码：

public class PersonTest {
      public static void main(String[] args) {
        //创建Person类的对象
        Person p = new Person ();
        //调用set方法,对成员变量赋值
        p.setAge(18);
        p.setName("张三");

        //调用类中的方法
        p.speak();

        //调用get方法，获取成员变量的值
        System.out.println(p.getAge());
        System.out.println(p.getName());
    }

}

3.4 this 关键字

如果上述标准代码由原来的：

改为：

则输出结果：

3.4.1 局部变量与成员变量的区别

    * 当类中存在成员变量和局部变量同名的时候为了区分，就需要使用this关键字。
    *在成员变量和局部变量同名的情况下，凡是需要方法访问成员变量的，则在输出变量时加上“this."即可，也就是说凡是this.XXX就是指成员变量。

图示：

标准代码：

public class Person {

    private String name ;
    private int age;

    public void setName(String n) {
    name = n;
    }
    public void setAge(int a) {
     age = a;
    }   

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    public void speak() {
        String name = "哈哈";
        int age =2;
        System.out.println(this.name+"..."+this.age);
    }

}

测试标准代码：

public class PersonTest {
      public static void main(String[] args) {

        Person p = new Person ();

        p.setAge(18);
        p.setName("张三");

        p.speak(); //输出结果为： 张三...18

        System.out.println(p.getAge());
        System.out.println(p.getName());
    }

}

3.4.2 对象内存解释

3.4.3 this的应用

标准代码：

public class Person {
    private int age ;

    public void setAge (int age) {
        this.age=age;
    }

    public int getAge() {
        return age;

    }
    /*
     * 定义一个方法：比较是否是同龄人，是就返回true，不是就返回false
     * 自己和 别人比较
     * 返回值： true false
     * 参数：别人
     */

    public boolean compare (Person p) {
        //自己和别人比
        return this.age == p.age;  
    }
}

测试标准代码：

public class personTest {
    public static void main(String[] args) {
        //测试Person类中的年龄比较功能
        //创建出2个Person对象
        Person p1 = new Person();
        Person p2 = new Person();

        p1.setAge(15);
        p2.setAge(16);

        //p1对象调用自己的方法compare 传递p2对象
        boolean b =p1.compare(p2);
        System.out.println(b);  //输出结果为：false

    }
}

第4章 随机点名案例重构

public class Student {
    private String name ;
    private int age;

    public void setName(String name) { 

            this.name = name;
    }
    public void setAge(int age) {

            this.age = age;
    }   


    //get方法，对变量age、name获取值 
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

}

import java.util.ArrayList;
import java.util.Random;

import cn.itcast.demo02.Student;


/*
 * 随机点名器
 * 1.创建集合，将Student对象存储到集合中
 * 2.总览所有学生的信息
 *   将存储到集合中的Student对象遍历出来
 * 3.随机学生
 *   随机数，作为索引，到集合中去查找元素
 */
public class CallName {
     public static void main(String[] args) {
    //定义集合ArrayList，存储到Student类型
       ArrayList<Student> array = new ArrayList<Student> ();
       addStudent(array);
       printStudent(array);
       randomStudent(array);

     }

     /*
        随机数生成学生信息
      */
     public static void randomStudent(ArrayList<Student> array) {
         Random r =new Random();
         int index = r.nextInt(array.size());
         Student s = array.get(index);
         System.out.println(s.getName());
     }



     /*
      * 定义方法，总览学生信息
      * 遍历集合
      */
     public static void printStudent(ArrayList<Student> array) {
         for(int i =0;i<array.size();i++) {
             Student s = array.get(i);
             System.out.println(s.getName()+"..."+s.getAge());
         }
     }


       /*
        * 定义方法，存储Student对象 ，到集合中
        */
       public static void addStudent(ArrayList<Student>  array) {
       Student s1 = new Student();
       s1.setName("lisi1");
       s1.setAge(151);

       Student s2 = new Student();
       s2.setName("lisi2");
       s2.setAge(152);

       Student s3 = new Student();
       s3.setName("lisi3");
       s3.setAge(153);

       Student s4 = new Student();
       s4.setName("lisi4");
       s4.setAge(154);

       Student s5 = new Student();
       s5.setName("lisi5");
       s5.setAge(155);

       array.add(s1);
       array.add(s2);
       array.add(s3);
       array.add(s4);
       array.add(s5);
       }
}