学习面向对象的三条主线

Java类及类的成员：属性、方法、构造器、代码块、内部类
面向对象的三大特征：封装、继承、多态
其他关键字：this、super、static、final、abstract、interface、package、import

4.1 面向过程与面向对象

4.1.1 面向过程（POP）、面向对象（OOP）

二者都是一种思想，面向对象是相对于面向过程而言的。

1、面向过程

强调的是功能行为，以函数为最小单位，考虑怎么做。

2、面向对象

将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、酚类、继承、聚合、多态等。

3、把大象装进冰箱

面向过程
1. 把冰箱门打开
2. 抬起大象，塞进冰箱
3. 把冰箱门关闭
面向对象
- 人
  - 打开冰箱
  - 抬起大象
- 冰箱
  - 开门
  - 关门
- 大象
  - 进入冰箱

4.1.2 面向对象的三大特征

封装（Encapsulation）
继承（Inheritance）
多态（Polymorphism）

4.1.3 面向对象的思想概述

程序员从面向过程的执行之转化成了面向对象的指挥着。
面向对象分析方法分析问题的思路和步骤：
1. 根据问题需要，选择问题所针对的现实世界中的实体。
2. 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
3. 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
4. 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

4.2 Java语言的基本元素：类、对象

4.2.1 面向对象的思想概述

类（Class）和对象（Object）是面向对象的核心概念。
类：对一类事物的描述，是抽象的、概念上的定义。
对象：实际存在的该类事物的每个个体，因而也称为实例（instance）。
“万物皆对象”！
- 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。
- 涉及到Java语言与前端、后端数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
面向对象程序设计的重点是类的设计。类的设计，其实就是类的成员的设计。

4.2.2 Java类及类的成员

现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java代码世界是由诸多个不同功能的类构成的。

现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、……。那么，Java中用类class来描述事物也是如此。

常见的类的成员有：

属性：对应类中的成员变量
行为：对应类中的成员方法
Field = 属性 = 成员变量。
Method = （成员）方法 = 函数。

4.2.3 类和对象的使用

创建类，设计类的成员。
创建类的对象。
通过“对象.属性”或“对象.方法”调用对象的结构。

   public class Person {
       // 属性
       String name;
       int age = 1;
       boolean isMale;

       // 方法
       public void eat() {
           System.out.println("人可以吃饭！");
       }
       public void sleep() {
           System.out.println("人可以睡觉！");
       }
       public void talk(String language) {
           System.out.println("人可以说话，使用的是：" + language);
       }

       public static void main(String[] args) {
           // 1、创建Person类的对象
           Person p1 = new Person();

           // 2、调用对象的结构：属性、方法
           // 调用属性：“对象.属性”
           p1.name = "Tom";
           p1.isMale = true;
           System.out.println(p1.name);
           // 调用方法：“对象.方法”
           p1.eat();
           p1.sleep();
           p1.talk("Chinese");
       }

   }

4.2.4 体会类的多个对象的关系

如果创建了一个类的多个对象，则每个对象都独立拥有一套类的属性（非static的）。
这意味着，如果我们修改一个对象的属性a，不影响另一个对象的属性a的值。

  Person p1 = new Person();
  p1.name = "Tom";
  p1.isMale = true;
  System.out.println(p1.name);
  p1.eat();
  p1.sleep();
  p1.talk("Chinese");

  Person p2 = new Person();
  System.out.println(p2.name);    // null

  Person p3 = p1;
  System.out.println(p3.name);    // Tom

4.3 内存解析

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在对上分配。
通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

图片说明

4.4 类的成员之一：属性

4.4.1 属性与局部变量的对比

1、相同点

定义变量的格式：数据类型变量名 = 变量值。
先声明，后使用。
变量都有其对应的作用域。

2、不同点

在类中声明的位置不同
- 属性：直接定义在类的一对{}内。
- 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
权限修饰符不同
- 属性：可以在声明时，使用权限修饰符（private、public、缺省、protected），指明其权限。
- 局部变量：不可以使用权限修饰符。
默认初始化值
- 属性：根据其类型，都有默认初始化值。
  - 整型（byte、short、int、long）：0
  - 浮点型（float、double）：0.0
  - 字符型（char）：'\u0000'
  - 布尔型（boolean）：false
  - 引用数据类型：null
- 局部变量：没有默认初始化值。在调用局部变量之前，一定要显示赋值。
在内存中加载的位置
- 属性：加载到堆空间中（非static）
- 局部变量：加载到栈空间

4.5 类的成员之二：方法

1、方法

描述类应该具有的功能。

2、方法的声明

    权限修饰符 返回值类型 方法名(形参列表){
            方法体
    }

    class Customer {
        // 属性
        String name;
        int age;
        boolean isMale;

        // 方法
        public void eat() {
            System.out.println("客户吃饭！");
        }
        public void sleep(int hour) {
            System.out.println("休息了" + hour + "个小时！");
        }
        public String getName() {
            return name;
        }
        public String getNation(String nation) {
            String info = "我的国籍是：" + nation;
            return info;
        }
    }

3、权限修饰符

Java规定了4种权限修饰符：private、public、缺省、protected。

4、返回值类型：有返回值、没有返回值

如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中需要使用return关键字来返回指定类型的变量或常量。
如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return了。但是，如果使用的话，只能“return;”，表示结束此方法。

5、方法名

属于标识符，遵循标识符的规则和规范，“见名知意”。

6、形参列表

方法可以声明0个、1个或多个形参。
格式：

(数据类型1 形参1, 数据类型2 形参2, ……)

7、方法体

方法功能的体现。

8、return关键字

使用范围：使用在方法体中。
作用：
- 结束方法。
- 针对于有返回值类型的方法，使用“return 数据”方式，返回所要的数据，并结束方法。
注意点：return关键字后不可以声明执行语句。

9、方法使用中的注意点

方法的使用中，可以调用当前类的属性、方法。
方法A中又调用了方法A：递归。
方法中不可以定义方法。

4.6 匿名对象

我们创建的对象，没有显示地赋给一个变量名，即为匿名对象。
特征：匿名对象只能调用一次。
使用。

  public class Test {
      public static void main(String[] args) {
          Phone p = new Phone();
          System.out.println(p);
          p.sendEmail();
          p.playGame();

          // 匿名对象
          new Phone().sendEmail();
          new Phone().playGame();
          new Phone().price = 1999;
          new Phone().showPrice();
          PhoneFactory pFactory = new PhoneFactory();
          // 匿名对象的使用
          pFactory.show(new Phone());
      }

  }

  class PhoneFactory {
      public void show(Phone phone) {
          phone.sendEmail();
          phone.playGame();
      }
  }

  class Phone {
      double price;   // 价格


      public void sendEmail() {
          System.out.println("发送邮件！");
      }
      public void playGame() {
          System.out.println("玩游戏！");
      }
      public void showPrice() {
          System.out.println("手机价格为：" + price);
      }

  }

4.7 自定义数组的工具类

    public class ArrayUtil {
        // 求数组的最大值
        public static int getMax(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int max = arr[0];
            for (int i = 1; i < length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        }

        // 求数组的最小值
        public static int getMin(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int min = arr[0];
            for (int i = 1; i < length; i++) {
                if (arr[i] < min) {
                    min = arr[i];
                }
            }
            return min;
        }

        // 求数组的总和
        public static int getSum(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int sum = 0;
            for (int i = 0; i < length; i++) {
                sum += arr[i];
            }
            return sum;
        }

        // 求数组的平均值
        public static int getAvg(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int sum = getSum(arr);
            int avg = sum / length;
            return avg;
        }

        // 反转数组
        public static void reverse(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int temp;
            for (int i = 0; i < length / 2; i++) {
                temp = arr[i];
                arr[i] = arr[length - i - 1];
                arr[length - i - 1] = temp;
            }
        }

        // 复制数组
        public static int[] copy(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int res[] = new int[length];
            for (int i = 0; i < length; i++) {
                res[i] = arr[i];
            }
            return res;
        }

        // 数组排序
        public static void sort(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int temp;
            for (int i = 1; i < length; i++) {
                for (int j = 0; j < length - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }

        // 遍历数组
        public static void print(int[] arr) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            for (int i = 0; i < length; i++) {
                System.out.print(arr[i] + " ");
            }
        }

        // 查找指定元素
        public static int getIndex(int[] arr, int dest) {
            if (arr == null) {
                throw new RuntimeException("数组为空！");
            }
            int length = arr.length;
            if (length == 0) {
                throw new RuntimeException("数组长度为0！");
            }
            int left = 0;
            int right = length - 1;
            int mid;
            while (left <= right) {
                mid = (left+right)/2;
                if (arr[mid] == dest) {
                    return mid;
                } else if (arr[mid] < dest) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            return -1;
        }
    }

4.8 方法重载（Overload）

1、定义

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

同一个类、相同方法名。
参数列表不同：参数个数不同，参数类型不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。

2、在通过对象调用方法时，如何确定某一个指定的方法

方法名
参数列表

3、实例

    public class Test {
        public void mOL(int i) {
            System.out.println(i *i);
        }
        public void mOL(int i, int j) {
            System.out.println(i * j);
        }
        public void mOL(String s) {
            System.out.println(s);
        }
        public int max(int i, int j) {
            return i > j ? i : j;
        }
        public double max(double i, double j) {
            return i > j ? i : j;
        }
        public double max(double i, double j, double k) {
            double max = i;
            if (j > max) {
                max = j;
            }
            if (k > max) {
                max = k;
            }
            return max;
        }
    }

4.9 可变个数的形参

Java SE 5.0中提供了Varargs（variable number of arguments）机制，允许直接定义能和零个或多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个、……、n个。
可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
可变个数形参在方法的形参中，必须声明在末尾。
可变个数形参的方法的形参中，最多只能声明一个可变形参。

  // JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
  public static void test(int a, String[] books);

  // JDK 5.0：采用可变个数形参来定义方法，传入多个同一类型变量
  public static void test(int a, String ... books）;

实例

  public class Test {
      public void show(int i) {}
      public void show(String s) {}    // （1）
      public void show(String ... strs) {  // （2）
                  for(int i = 0; i < strs.length; i++) {
                          System.out.println(strs[i]);
                  }
          } 
          // public void show(String[] strs) {} 与（2）重复
          public void show(String[] strs, int[] ints){}

      public static void main(String[] args) {
          Test test = new Test();
          test.show(1);
          test.show("hello"); // （1）
          test.show("hello", "world");    // （2）
          test.show();    // （2）
                  test.show(new String[]{"A","B"});  // （2）
      }

  }

4.10 方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：
- 形参：方法声明时的参数
- 实参：方法调用时实际传给形参的参数值

1、变量的赋值

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值（含变量的数据类型）。

  public class Test {
      private int id;
      public static void main(String[] args) {
          int m = 10;
          int n = m;
          System.out.println("m: " + m + ", n: " + n);  // m: 10, n: 10
          n = 20;
          System.out.println("m: " + m + ", n: " + n);  // m: 10, n: 20
          Test t1 = new Test();
          t1.id = 10;
          Test t2 = t1;
          System.out.println("t1: " + t1.id + ", t2: " + t2.id);  // t1: 10, t2: 10
          t2.id = 20;
          System.out.println("t1: " + t1.id + ", t2: " + t2.id);  // t1: 20, t2: 20
      }
  }

1、Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值（含变量的数据类型）。

2、例题

    public class Test {
        public static void main(String[] args) {
            Test t = new Test();
            t.first();
        }
        public void first() {
            int i = 5;
            Value v = new Value();
            v.i = 25;
            second(v, i);
            System.out.println(v.i);    // 20
        }
        public void second(Value v, int i) {
            i = 0;
            v.i = 20;
            Value val = new Value();
            v = val;
            System.out.println(v.i + " " + i);      // 0 0
        }
    }
    class Value {
        int i;
    }

    public class Test {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            method(a, b);
            System.out.println("a = " + a + ", b = " + b);
        }
        public static void method(int a, int b) {
            System.out.println("a = " + (a * 10) + ", b = " + (b * 10));
            System.exit(1);
        }
    }

    public class Test {
        public static void main(String[] args) {
            int[] arr = new int[]{1,2,3};
            System.out.println(arr);    // [I@54bedef2
            char[] arr1 = new char[]{'a','b','c'};
            System.out.println(arr1);   // abc
        }
    }

    public class PassObject {
        public static void main(String[] args) {
            PassObject passObject = new PassObject();
            passObject.printAreas(new Circle(), 5);
        }

        public void printAreas(Circle c, int time) {
            System.out.println("Radius\t\tArea");
            for(int i = 1; i <= time; i++) {
                c.radius = i;
                System.out.println(c.radius + "\t\t" + c.findArea());
            }
        }
    }
    //-------------------
    public class Circle {
        double radius;  // 半径

        /**
         * 求圆的面积
         * @return
         */
        public double findArea() {
            return Math.PI * radius * radius;
        }
    }

4.11 递归（recursion）方法

递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就会变成了无穷递归，类似于死循环。

  public class Test {
      public static void main(String[] args) {
          System.out.println(sum(100));
      }

      public static int sum(int n) {
          if(n == 1) {
              return 1;
          } else {
              return sum(n-1) + n;
          }
      }

  }

  public class Test {
      public static void main(String[] args) {
          System.out.println(f(10));
      }

      public static int f(int n) {
          if(n == 0) {
              return 1;
          } else if (n == 1) {
              return 4;
          } else {
              return 2 * f(n-1) + f(n-2);
          }
      }

  }

  public class Test {
      public static void main(String[] args) {
          System.out.println(fibonacci(10));
      }

      public static int fibonacci(int n) {
          if(n == 1 || n == 2) {
              return 1;
          } else {
              return fibonacci(n-1) + fibonacci(n-2);
          }
      }

  }

4.12 面向对象特征之一：封装与隐藏

我们程序设计追求“高内聚，低耦合”。
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

4.12.1 问题的引入

当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值。这里i，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）

同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值，则需要将属性声明为私有的（private）。

此时，针对于属性就体现了封装性。

    public class Test {
        public static void main(String[] args) {
            Animal a = new Animal();
            a.name = "大黄";
            a.age = 1;
            // a.legs = 4; // The field Animal.legs is not visible
            a.show();

            // a.legs = -4;
            // a.setLegs(6);
            a.setLegs(-6);
            a.show();
        }
    }

    class Animal{
        String name;
        int age;
        private int legs;

        public void setLegs(int legs) {
            if(legs >= 0 && legs % 2 == 0)  {
                this.legs = legs;
            } else {
                this.legs = 0;

            }
        }

        public void eat() {
            System.out.println("动物进食！");
        }
        public void show() {
            System.out.println("name = " + name + ", age = " + age + ", legs = " + legs);
        }
    }

4.12.2 封装性的体现

我们将类的属性私有化（private），同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值。

封装性的体现

如上
不对外暴露的私有方法
单例模式
……

  public class Test {
      public static void main(String[] args) {
          Animal a = new Animal();
          a.name = "大黄";
          // a.age = 1;
          // a.legs = 4; // The field Animal.legs is not visible
          a.show();

          // a.legs = -4;
          // a.setLegs(6);
          a.setLegs(-6);
          a.setLegs(6);
          a.show();
          // System.out.println(a.legs);
          System.out.println(a.getLegs());
      }

  }

  class Animal{
      private String name;
      private int age;
      private int legs;

      public void setAge(int age) {
          this.age = age;
      }
      public int getAge() {
          return age;
      }
      public void setName(String name) {
          this.name = name;
      }
      public String getName() {
          return name;
      }

      public void setLegs(int legs) {
          if(legs >= 0 && legs % 2 == 0)  {
              this.legs = legs;
          } else {
              this.legs = 0;

          }
      }

      public int getLegs() {
          return legs;
      }

      public void eat() {
          System.out.println("动物进食！");
      }
      public void show() {
          System.out.println("name = " + name + ", age = " + age + ", legs = " + legs);
      }

  }

4.12.3 封装性的体现，需要权限修饰符来配合

1、Java规定的四种权限（从小到大）

private
缺省
protected
public

图片说明

4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类。
具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类。
修饰类的话，只能用：缺省、public。

2、封装性总结

Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

3、封装性练习

    package package1;
    public class Person {
        private int age;

        public void setAge(int a) {
            if(a < 0 || a > 130) {
                throw new RuntimeException("传入的数据非法！");
            }
            age = a;
        }

        public int getAge() {
            return age;
        }
    }
    //===============
    package package1;
    public class PersonTest {
        public static void main(String[] args) {
            Person p1 = new Person();
            // p1.age = 1; 编译不通过
            p1.setAge(12);
            System.out.println(p1.getAge());
        }
    }

4.13 类的成员之三：构造器（或构造方法、constructor）

4.13.1 构造器的作用：创建对象

创建对象：new+构造器。
初始化对象的属性。

4.12.2 说明

如果没有显示的定义类的构造器的话，则系统默认提供一个无参的构造器。
一个类中定义的多个构造器，彼此构成重载。
一旦我们显示的定义了类的构造器之后，系统就不再提供默认的无参构造器。
一个类中，至少会有一个构造器。
定义构造器的格式：

   权限修饰符 类名(形参列表){

   }

   package package1;
   public class Person {
       private int age;

       // 构造器
       public Person() {

       }

       public void setAge(int a) {
           if(a < 0 || a > 130) {
               throw new RuntimeException("传入的数据非法！");
           }
           age = a;
       }

       public int getAge() {
           return age;
       }

   }

4.12.3 总结：属性赋值过程

1、属性赋值的先后顺序

默认初始化
显示初始化
构造器
通过“对象.方法”或“对象.属性”

4.13 扩展知识：JavaBean

JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean，是指符合如下标准的Java类：
- 类是公共的。
- 有一个无参的公共的构造器。
- 有属性，且有对应的get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供给了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

  public class Customer {
      private int id;

      public Customer() {}

      public void setId(int id) {
          this.id = id;
      }
      public int getId() {
          return id;
      }

  }

4.14 扩展知识：UML类图

图片说明

+表示public类型，-表示private类型，#表示protected类型。
方法的写法：方法的类型（+、-）方法名（参数名：参数类型）：返回值类型
- setId(id: int) : void

4.15 关键字：this的使用

this —> 当前对象 / 当前正在创建的对象
this可以用来修饰：属性、方法、构造器
在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显示的使用“this.变量”的方式，表明此变量是属性，而非形参。
在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显示的使用“this.变量”的方式，表明此变量是属性，而非形参。
this调用构造器
- 我们在类的构造器中，可以显示的使用“this(形参列表)”方式，来调用本类中指定的其他构造器。
- 构造器不能通过“this(形参列表)”方式调用自己。
- 如果一个类中有n个构造器，则最多有n-1个构造器中使用了“this(形参列表)”。
- 规定：“this(形参列表)”必须声明在当前构造器的首行。
- 构造器内部，最多只能声明一个“this(形参列表)”，用来调用其他构造器。

  public class Test {
      public static void main(String[] args) {
          Person p1 = new Person();
          p1.setAge(1);
          System.out.println(p1.getAge());
      }
  }

  class Person {
      private String name;
      private int age;

      public Person() {}

      public Person(String name) {
                  this();
          this.name = name;
      }

      public Person(String name, int age) {
          this(name);
          this.age = age;
      }

      public void setName(String name) {
          this.name = name;
      }
      public String getName() {
          return name;
      }
      public void setAge(int age) {
          this.age = age;
      }
      public int getAge() {
          return age;
      }

      public void eat() {
          System.out.println("人吃饭！");
          this.study();
      }

      public void study() {
          System.out.println("人学习！");
      }

  }

练习

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

      public Boy() {}
      public Boy(String name, int age) {
          this.name = name;
          this.age = age;
      }

      public void setName(String name) {
          this.name = name;
      }
      public String getName() {
          return name;
      }
      public void setAge(int age) {
          this.age = age;
      }
      public int getAge() {
          return age;
      }

      public void marry(Girl girl) {
          System.out.println("我想娶" + girl.getName());
      }

      public void shout() {
          if(this.age >= 22) {
              System.out.println("你可以去合法登记结婚了！");
          } {
              System.out.println("先多谈谈恋爱~~");
          }
      }

  }
  //========================
  public class Girl {
      private String name;
      private int age;

      public Girl() {}
      public Girl(String name, int age) {
          this.name = name;
          this.age = age;
      }

      public void setName(String name) {
          this.name = name;
      }
      public String getName() {
          return name;
      }
      public void setAge(int age) {
          this.age = age;
      }
      public int getAge() {
          return age;
      }

      public void marry(Boy boy) {
          System.out.println("我想嫁给" + boy.getName());
          boy.marry(this);
      }
      /**
       * 比较两个对象的大小
       * @param girl
       * @return 正数：当前对象大；负数：当前对象小；0：当前对象与形参对象相等
       */
      public int compare(Girl girl) {
          // if(this.age > girl.age) {
          //     return 1;
          // } else if(this.age < girl.age) {
          //     return -1;
          // } else {
          //     return 0;
          // }
          return this.age - girl.age;
      }

  }

4.16 关键字：package、import的使用

4.16.1 package

为了更好的实现项目中类的管理，提出包的概念。
使用package声明类或接口所属的包，声明在源文件的首行。
包属于标识符，遵循标识符的命名规则、规范（小写：xxxyyyzzz）、“见名知意”。
每“.”一次，就代表一层文件目录。
补充：同一个包下，不能命名同名的接口、类。
JDK中主要的包
- java.lang——包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
- java.net——包含执行与网络相关的操作的类和接口。
- java.io——包含能提供多种输入/输出功能的类。
- java.util——包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
- java.text——包含了一些Java格式化相关的类。
- java.sql——包含了Java进行JDBC数据库编程的相关类/接口。
- java.awt——包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。

4.16.2 MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层、控制器层、数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变得灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

图片说明

模型层（model）：主要处理数据
- 数据对象封装：model.bean/domain
- 数据库操作类：model.dao
- 数据库：model.db
控制层（controller）：处理业务逻辑
- 应用界面相关：controller.activity
- 存放fragment：controller.fragment
- 显示列表的适配器：controller.adapter
- 服务器相关的：controller.service
- 抽取的基类：controller.base
视图层（view）：显示数据
- 相关工具集：view.utils
- 自定义view：view.ui

4.16.3 import

import：导入。
在源文件中显式的使用import结构导入指定包下的类、接口。
```
import java.util.Arrays;
```
声明在包的声明和类的声明之间。
如果需要导入多个结构，则并列写出即可。
可以使用"xxx.*;"的方式，表示可以导入xxx包下的所有结构。
如果使用的类或接口是java.lang包下定义的，则可以省略import结构。
如果使用的类或接口是本包写定义的，则也可以省略import结构。
如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的发哪个好似显示。
```
com.xxx.Account acct1 = new com.xxx.Account();
```
使用“xxx.*”方式表明可以调用xxx包下的所有结构，但是如果使用的是xxx子包下的结构，则仍需要显示导入。
```
import java.lang.reflect.Field;  // 不在lang包下，需要自己导入
```
import static：导入指定类或接口中的静态结构。
```
import static java.lang.System.*;
```

4 面向对象（上）

学习面向对象的三条主线

4.1 面向过程与面向对象

4.1.1 面向过程（POP）、面向对象（OOP）

1、面向过程

2、面向对象

3、把大象装进冰箱

4.1.2 面向对象的三大特征

4.1.3 面向对象的思想概述

4.2 Java语言的基本元素：类、对象

4.2.1 面向对象的思想概述

4.2.2 Java类及类的成员

4.2.3 类和对象的使用

4.2.4 体会类的多个对象的关系

4.3 内存解析

4.4 类的成员之一：属性

4.4.1 属性与局部变量的对比

1、相同点

2、不同点

4.5 类的成员之二：方法

1、方法

2、方法的声明

3、权限修饰符

4、返回值类型：有返回值、没有返回值

5、方法名

6、形参列表

7、方法体

8、return关键字

9、方法使用中的注意点

4.6 匿名对象

4.7 自定义数组的工具类

4.8 方法重载（Overload）

1、定义

2、在通过对象调用方法时，如何确定某一个指定的方法

3、实例

4.9 可变个数的形参

4.10 方法参数的值传递机制

1、变量的赋值

1、Java的实参值如何传入方法呢？

2、例题

4.11 递归（recursion）方法

4.12 面向对象特征之一：封装与隐藏

4.12.1 问题的引入

4.12.2 封装性的体现

4.12.3 封装性的体现，需要权限修饰符来配合

1、Java规定的四种权限（从小到大）

2、封装性总结

3、封装性练习

4.13 类的成员之三：构造器（或构造方法、constructor）

4.13.1 构造器的作用：创建对象

4.12.2 说明

4.12.3 总结：属性赋值过程

1、属性赋值的先后顺序

4.13 扩展知识：JavaBean

4.14 扩展知识：UML类图

4.15 关键字：this的使用

4.16 关键字：package、import的使用

4.16.1 package

4.16.2 MVC设计模式

4.16.3 import