面向对象（封装，this，static，代码块）

1、面向对象的思想  

      面向对象的思想是基于面向过程的编程思想

      面向过程：强调的是每个功能的实现步骤  （参与者）
      面向对象：强调的是对象，然后由这个对象去调用方法（指挥者）

2、面向对象的特点

    1)、是一种更加符合我们思想习惯的一个概念
    2)、可以将复杂的事情简单化
    3)、将我们从参与者变成了指挥者

举例：
    吃饭：
        面向过程：先去超市买菜--洗菜--切菜--炒菜--装盘--吃
        面向对象：去饭店吃--你（点菜）--厨师（做菜）--服务员（上菜）--吃
    打水：
        面向过程：拿起水杯--走到饮水机面前--选择热水还是冷水--接水--喝
        面向对象：让同桌打水--告诉他（她）打冷水还是热水--同桌打水--喝
    学大数据：
        面向过程：自己去找资料--自己看视频--自己理解代码--学不会
        面向对象：来数加--老师教你--老师帮助你去理解--学会了

把大象装进冰箱
        面向过程的思想：
            1、打开冰箱门
            2、把大象放进冰箱
            3、关闭冰箱门
   

    代码体现：
        class Demo{
            public static void main(String[] args){
                //System.out.println("打开冰箱门");
                //假设我要打开很多次冰箱,就要写很多次打开冰箱的代码
                //需要用方法改进

                open();
                discharge();
                close();
            }

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

            public static void discharge(){
                System.out.println("把大象放进冰箱");
            }
            public static void close(){
                System.out.println("关闭冰箱门冰箱门");
            }
}

  

面向对象的思想去实现：
        1、我们要考虑有哪些类？
        2、考虑每个类中都有些什么呢？
        3、类与类之间的关系是什么样子的呢？

    分析：（如何分析有哪些类呢？UML 名词提取法）
    1、有哪些类呢？
        大象
        冰箱
        测试类
    2、每个类里面都有什么呢？
        大象：
            进冰箱
        冰箱：
            开
            关
        测试类：
              main
    3、类与类之间的关系是什么样子的呢？
        编写测试类使用大象和冰箱的功能

 代码体现：
        class Elephant{
            public void enterFrig(){
                System.out.println("把大象放进冰箱里");
            }
        }

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

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

//测试类 class Demo{
            public static void main(String[] args){
                Frig f = new Frig();  //创建冰箱对象
                f.open();

                Elephant e = new Elephant();  //创建大象对象
                e.enterFrig();

                f.close();
            }
        }

        一个文件里写两个类：一个类是基本的类、一个类是测试类
        注意事项：
            1、文件的名称要与测试类的名称一致
            2、同包下，类名不能重复
            3、将来编译的时候，有多少个class就编译出多少个class文件

        如何使用类呢？
            创建对象使用

        如何创建对象呢？
            格式：
                类名 对象名称 = new 类名();

3、面向对象的开发、设计、特征

        1）面向对象的开发
            就是不断地创建对象、使用对象、指挥对象做事情

         2）面向对象的设计
            其实就是在管理和维护对象之间的关系。

        3）面向对象的特征
              封装
              继承
              多态

 类和对象
类：现实生活中具有相同属性和行为事物的抽象（泛指看不见摸不着的）
        组成：
         1）属性：成员变量（public 数据类型 变量名；）
         2）行为：成员方法（public 返回数据类型 方法名（参数）{}）

对象：现实生活中具体的存在（实体，看得见摸得着）
     1）创建格式：
                类名 对象名 = new 类名（）；
     2）使用成员：
                1）使用成员变量（赋值/取值）
                        对象名.成员变量；
                2）使用成员方法（调用）
                        对象名.成员方法；

关系：类是对象的集合，对象是类的实现
       Java中先有类再有对象
       类可以看作是对象的数据类型

现实世界中是如何描述一个事物的呢？
我们学习编程语言，就是为了模拟现实世界的事物的
而我们现在学的语言是：Java       Java中最基本的单位是：类
所以，我们通过Java中用类把事物给描述出来
现实生活中的事物与类之间的对应关系

事物                                         类
    属性：事物的描述信息叫做属性              成员变量
    行为：就是事物能够做什么                  成员方法


举例：
        事物：人                               类：Person 
        属性：姓名、年龄、性别、身高            成员变量：name、age、gender、high
        行为：吃饭、喝水、学习                  成员方法：eat(),drink(),study()

对象：是该类事物的具体表现。学生、老师、医生、程序员

4、对象内存图 

5、成员变量和局部变量的区别
    1）在类中定义的位置不同
       成员变量：定义在类中，但是在方法外
       局部变量：定义在方法中
    2）在内存中的位置不同
       成员变量：在堆内存中
       局部变量：在栈内存中
    3）生命周期也不同
       成员变量：随着对象的创建而存在，随着对象的消失而消失
       局部变量：随着方法的调用而存在，随方法的调用完毕而消失
    4）初始化值不同
       成员变量：有默认初始化值，系统给的
       局部变量：没有系统给默认初始化值，必须在定义的时候赋值，或者在使用前赋              
                值，然后才能使用

    注意事项：
           1、方法与方法之间里面的局部变量不可以互相访问
           2、局部变量可以和成员变量的名称一样，在方法中使用的时候，采用就近原则

6、匿名对象

      就是没有名字的对象，是对象的一种简化表示形式

      匿名对象的两种使用情况：

                1） 对象调用方法仅仅一次的时候

                2）作为实际参数传递 

class Cat1{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

public class Test1 {
    public static void main(String[] args) {
          Cat1 c =new Cat1();  //
          c.eat();  //

        //匿名对象
          new Cat1().eat();
    }
}

7、封装（private）

      其实就是隐藏对象的属性和相关实现细节，仅仅对外提供公共的访问方法

针对强制要求调用者必须使用定义的方法来对成员变量赋值这样的情况，
 Java提供了一个关键字：private  
        使用格式： private 数据类型 成员变量名;  
        private:     
              1）是一个权限修饰符。      
              2）可以修饰成员(成员变量和成员方法)  
              3）被private修饰的成员只在本类中才能访问。

        权限访问修饰符：
                 public：公共的
                 private：私有的

 private和封装的应用     
      1）把成员变量用private修饰      
      2）提供对应公共的setXxx()和getXxx()方法


 1）通过对象给成员变量赋值的时候，我们可以给一些非法的不贴合现实的数据。
    代码编译和运行都不报错，但是这样的数据是不合理。
 
 2）我们正确的思路应该是在赋值之前，做一次数据校验，就是对数据进行一次判断。
    所以，我们应该在Student2类中提供一个方法来做数据校验和赋值

 3） private修饰成员变量，通过方法再对成员变量赋值，先传递给方法，再赋值（可以在传递和     赋值之间通过代码验证这个值是否符合现实）

---

定义一个学生类

     成员变量：name,age

     成员方法：show()方法

class Student2{
   //定义成员变量
    String name;
    private int age;

  //在Student2类中提供一个方法来做数据校验和赋值
    public void setAge(int i){ 
        if(i<0 || i>150){
            System.out.println("输入的年龄不合法");
        }else {
            age = i;
        }

    }

   //定义成员方法
    public void show(){
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
    }

}

//测试类
public class StudentDemo1 {
    public static void main(String[] args) {
        //创建学生对象
        Student2 s = new Student2();
        s.name = "陈俊荣";
        s.setAge(-17);  //输入的年龄不合法
        s.setAge(17);
        s.show();

    }
}

---

 private修饰的成员变量，别的类无法使用，如若想使用，在当前类中书写方法供别的类使用

定义get成员变量名（）；获取private修饰的成员变量

定义set成员变量名（）；赋值private修饰的成员变量

8、this关键字

  针对出现的局部变量和成员变量同名的问题,
  Java中提供了一个关键字：this  当调用这个方法时，this就代表当前对象
  
  this:是当前类的对象的引用。
  简单记：它就代表了当前类的对象，每个对象都有个this。当局部变量与成员变量同名时，带               this修饰的就是成员变量
  注意：谁调用类中的方法，那个方法内的this就代表谁

---

class Student{
    private String name;
    private int age;
    //getXxx
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    //setXxx
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    //输出所有变量的方法show();
    public void show(){
        System.out.println(this.name+"---"+this.age);
    }

}

public class Test91 {
    public static void main(String[] args) {
        //创建对象
        Student s=new Student();
        //setXxx给成员变量赋值
        s.setName("小陈");
        s.setAge(23);
        s.show();  //小陈---23

    }
}

9、构造方法

构造方法格式:
     1）方法的名字与类名相同
     2）没有返回值类型，连void都没有
     3）没有具体的返回值

无参构造与带参构造：

        //无参构造
        Student3() {
        }

        //带参数的构造方法
        Student3(String name, int age) {
            this.name = name;
            this.age = age;
        }

注意：
     1）如果我们没有给出构造方法，JVM虚拟机会自动给我们提供一个无参的构造方法
     2）如果给出了构造方法，JVM虚拟机不会再提供默认的无参构造方法。
        如果还想用无参构造方法，就必须自己给出来
        JVM发现我们自己一旦给出了构造方法（无论是无参构造还是带参构造），
        就永远不会给出默认的无参构造。
     3）构造方法可以发生重载（方法名一致，参数列表不一样）

构造方法的作用：
     可以给成员变量初始化值,如果调用的是无参构造，系统给默认值

---

给成员变量赋值的方式：
 1、使用setXxx()的形式给成员变量赋值
        s.setName("小花"); 
        s.setAge(22);
 2、使用带参数的构造方法给成员变量赋值，配合this指针使用  
        Student s = new Student("小花",22);

获取成员变量的两种方式：
   1、使用我们提供的getXxx()获取
       System.out.println(s.getName()+"---"+s.getAge());
   2、调用提供的输出所有成员变量的方法
         s.show();

10、static关键字 

针对同一个类创建出来的多个对象所拥有的相同的成员变量，该成员变量的值是一样的时候
Java就提供考虑一个关键字给我们处理这样的情况：static

static关键字可以修饰成员变量和成员方法，被static修饰的成员变量可以让所有对象共享

static关键字的特点：
    1）随着类的加载而加载
        观察以下main
    2）优先于对象存在
    3）被类的所有对象共享
        举例：所有的中国人的国籍信息都一样，都是中国
        什么时候使用静态static关键字呢？
            某个成员变量被所有的对象共享的时候，那么它就应该被定义为静态的。
        举例：
            哈罗电单车（可以被静态修饰）
            自己的水杯（不可以被静态修饰）
    4）可以通过类名调用
        一般情况下，我们只需要看到一个类中有静态修饰的成员变量或者成员方法
        一律采用 类名.静态成员 这种方式去访问
        推荐使用类名调用
        静态修饰的成员一般称之为：类成员，与类相关的成员

static关键字使用的注意事项：
     1）在静态方法中是没有this关键字的
        //成员变量
        private static String clazz;

        //成员方法
        public static String getClazz() {
            return clazz;
        }
        public static void setClazz(String clazz) {
            Student4.clazz = clazz;
        }

        //创建对象
        Student4 s = new Student4("小陈",17);
        Student4.setClazz("十三班");

     2）静态方法：可以访问静态的成员变量和静态的成员方法
     3）非静态的方法：既可以访问非静态的成员变量和静态的成员变量
                     也可以访问非静态的成员方法和静态的成员方法
        如果你是在记不住，总结一句话：
            静态的只能访问静态

11、代码块

在Java中，使用{}括起来的代码被称为代码块，
根据其位置和声明的不同，
可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

1）局部代码块：
    在方法中出现；
        作用：限定变量的生命周期，及早释放，提高内存利用率
    在同一个类出现的时候，多个局部代码块的执行顺序是自上而下的。

2）构造代码块：
    在类中方法外出现的；多个构造方法方法中相同的代码存放到一起，
    每次调用构造都执行，并且在构造方法前执行

    执行顺序：
        局部代码块 ---> 构造代码块 ---> 构造方法

3）静态代码块：
    在类中方法外出现，并加上static修饰；
    用于给类进行初始化，在加载的时候就执行，并且只执行一次。

        局部代码块 ---> 静态代码块 ---> 构造代码块 ---> 构造方法


    静态代码块在一个类中的顺序，不影响它的执行顺序，但是多个静态代码块在一个类中，
        他们之间的执行顺序是自上而下的。

class Student{

    static {
        System.out.println("这是在Stduent类中的静态代码块"); // 3
    }

    {
        System.out.println("这是在Student类中构造代码块"); // 4
    }
    Student(){
        System.out.println("这是在Student类中的无参构造的方法"); // 5
    }
}

public class StudentDemo {

    static {
        System.out.println("这是在StudentDemo中的静态代码块"); // 1
    }

    public static void main(String[] args) {
        System.out.println("进入到main方法"); // 2
        Student s = new Student();

    }
}