Java面向对象学习的三条主线

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

面向过程和面向对象

面向过程 (POP) 与面向对象 (OOP)
二者都是一种思想，面向对象时相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了对象的功能，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中次啊用的思想方法与原则，如抽象、分类、继承、聚合、多态等
面向对象的三大特征
- 封装（Encapsulation）
- 继承（Inheritance）
- 多态（Polymorphism）

面向对象：Object Oriented Programming
面向过程：Proecdure Oriented Programming

面向对象思想概述

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

类和对象

类 (Class) 和 对象 (Object) 是面向对象的核心概念
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因为也称为实例 (instance)
“ 万事万物皆对象 ”

Java类及类的成员

现实世界的生物体，大到鲸鱼，小到蚂蚁，基本都是由最基本的细胞构成的。同理，Java 代码世界是由诸多个不同功能的类构成
现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、……那么，Java 中用类 class 来描述事物也是如此。常见的类的成员有：
- 属性：对应类中的成员变量
- 行为：对应类中的成员方法

类和对象的创建及其使用

package com.atguigu.java;
/* 一、设计类，其实就是设计类的成员
 * 属性 = 成员变量 = field = 域、字段
 * 方法 = 成员方法 = 函数 = method
 * 创建类的对象 = 类的实例化 = 实例化类
 * 
 * 二、类和对象的使用（面向对象思想落地的实现）
 * 1. 创建类，设计类的成员
 * 2. 创建类的对象
 * 3. 通过 “对象.属性” 或 “对象.方法” 调用对象的结构
 * 
 * 三、 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static）
 *        意味着：如果我们修改一个对象的属性 a，则不影响另外一个对象属性 a 的值
 */
// 测试类
public class PersonTest {
    public static void main(String[] args) {
        // 2.创建 Person 类的对象
        Person p1 = new Person();
        
        // 调用对象的结构：
        // 调用属性：对象.属性
        p1.name = "Tim";
        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
        System.out.println(p2.isMale);
        // **************************
        // 将 p1 变量保存的对象地址值赋给 p3，导致 p1 和 p3 指向了堆空间中的同一个对象实体。
        Person p3 = p1;
        System.out.println(p3.name);  // Tim
        
        p3.age = 10;
        System.out.println(p1.age);  //10
    }
}
/*
 * 类的语法格式：
 * 修饰符 class 类名{
 *         属性声明;
 *         方法声明;
 * }
 * 说明：修饰符 public：类可以被任意访问类的正文要用{  }括起来
 */
// 1.创建类，设计类的成员
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);
    }
}

内存解析

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

类的成员

属性

属性（成员变量） vs 局部变量

相同点

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

不同点

在类中声明的位置不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符
常用的权限修饰符：private、public、缺省、protected
局部变量：不可以使用权限修饰符

默认初始化值的情况：
属性：类的属性，根据其类型，都有默认初始化值

  整形（byte、short、int、long）：0
  浮点型（float、double）：0.0
  字符型（char）：0（或'\u0000'）
  布尔型（boolean）:false;
  引用数据类型（类、数组、接口）：null

局部变量：没有默认初始化值

  意味着，我们在调用局部变量之前，一定要显式赋值
  特别的：形参在调用时赋值即可

在内存中加载的位置不同：
属性：加载到堆空间（非static）
局部变量：加载到栈空间

public class UserTest {
    public static void main(String[] args) {
        User u1 = new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);
        
        u1.talk("日语");
    }
}

class User {
    // 属性（成员变量）
    String name;
    public int age;
    boolean isMale;
    public void talk(String language) { // language:形参
        System.out.println("我们使用" + language + "进行交流");
    }
    public void eat() {
        String food = "烙饼"; // 局部变量
        System.out.println("北方人喜欢吃" + food);
    }
}

练习

编写教师类和学生类，并通过测试类创建对象进行测试
Student类
属性:
name:String
age:int
major:String
interests:String
方法:say() 返回学生的个人信息
Teacher类
属性:
name:String
age:int
teachAge:int
course:String
方法:say() 输出教师的个人信息

public class ClassExers {
    public static void main(String[] args) {
        Students std = new Students();
        System.out.println(std.say("xiaokai", 18, "computer", "code"));
        
        Teacher teach = new Teacher();
        teach.name = "xiaokai";
        teach.age = 18;
        teach.teachAge = 1;
        teach.course = "computer";
        teach.say();
    }
}

class Students {
    String name, major, interests;
    int age;

    public String say(String name, int age, String major, String interests) {
        String std = name + " " + age + " " + major + " " + interests;
        return std;
    }
}

class Teacher {
    String name, course;
    int age, teachAge;
    public void say(){
        String teach = name + " " + age + " " + course + " " + teachAge;
        System.out.println(teach);
    }
}

方法

关于权限修饰符：默认方法的权限修饰符先都使用 public
- Java 规定的 4 种权限修饰符：private、public、缺省、protected ==> 封装性再细说
返回值类型：有返回值 vs 没有返回值
- 如果方法有返回值，则必须在方法声明时，指定返回值的类型，同时，方法中，需要使用 return 关键字来返回指定类型的变量或常量：“return 数据”，如果方法没有返回值，则方法声明时，使用 void 来表示。通常，灭有返回值的方法中，就不适用 return。但是，如果使用的话，只能“return;”表示结束此方法的意思
- 我们定义方法该不该有返回值
  - 题目要求
  - 凭经验：具体问题具体分析
- 方法名：标识符，遵循标识符的规则和规范，“见名知意”
- 形参列表：方法可以声明 0 个，1 个，或多个形参
  - 格式：数据类型1 形参1, 数据类型2 形参2, ……
  - 我们定义方法时，该不该定义形参？
    - 题目要求
    - 凭经验：具体问题具体分析
- 方法体：方法功能的实现
return 关键字的使用
- 使用范围：使用在方法体
- 作用：
  - 结束方法
  - 针对于有返回值类型方法，使用“return 数据”方法返回所要的数据
- 注意点：return 关键字后面不可以声明执行语句
方法的使用中，可以调用当前类的属性或方法
- 特殊的：方法 A 中又调用了方法 A：递归方法
- 方法中，不可以定义方法

public class CustomerTest {
    public static void main(String[] args) {
        Customer cust1 = new Customer();

        cust1.eat();
        // int[] arr = new int[]{1,2,4,6,4,2,31,3,5,12,123,54};
        // cust1.sort(arr);
        cust1.sleep(8);
    }
}

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

    // 方法
    public void eat() {
        System.out.println("客户吃饭");
        return;
        // System.out.println("1234");
    }

    public void sleep(int hour) {
        System.out.println("休息了" + hour + "个小时");
        eat();
    }

    public String getName() {
        if (age > 18) {
            return name;
        } else {
            return "Tim";
        }
    }

    public String getNation(String nation) {
        String info = "我的国际是：" + nation;
        return info;
    }

    // 形参是否需要设置
//    public void sort(int[] arr) {
//
//    }
}

练习

/*
 * 要求：
 * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，
 * 输出字符串“studying”，调用showAge( )方法显示age值，
 * 调用addAge( )方法给对象的age属性值增加2岁。
 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
 */
public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "tom";
        p1.age = 18;
        p1.sex = 1;
        
        p1.study();
        p1.showAge();
        int newAge = p1.addAge(2);
        System.out.println(p1.name + "的新年龄为： " + newAge);
        System.out.println(p1.age);
        // **********************************************
        Person p2 = new Person();
        p2.showAge();  // 0
    }
}
class Person {
    String name;
    int age;
    /**
     * sex:1表示男性
     * sex:0表示女性
     */
    int sex;
    
    public void study(){
        System.out.println("syudying");
    }
    public void showAge(){
        System.out.println("age:" + age);
    }
    public int addAge(int i){
        age += i;
        return age;
    }
}

利用面向对象的编程方法，设计类 Circle 计算圆的面积。

// 测试类
public class ClrcleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        c1.radius = 2.1;
        // System.out.println(c1.findArea());
        c1.findArea();
        // System.out.println(c1.findAreaError(2.1));
    }
}

// 园
class Circle {
    // 属性
    double radius;

    // 求圆的面积
    // 方式一：
    // public double findArea() {
    // return Math.PI * radius * radius;
    // }
    // 方式二：
    public void findArea() {
        double area = Math.PI * radius * radius;
        System.out.println("面积为:" + area);
    }

    // 错误示范
    // public double findAreaError(double r) {
    // return Math.PI * r * r;
    // }
}

编写程序，声明一个method方法，在方法中打印一一个108 的型矩形，在main方法中调用该方法。
修改上一个程序，在method方法中，除打印一个10 8的型矩形外，再计算该矩形的面积
并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印
修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m n的型矩形
并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

public class Exer3Test {
    public static void main(String[] args) {
        Exer3Test test = new Exer3Test();
        // 方式一
        // int area = test.method();
        // System.out.println("面积为：" + area);

        // 方式二
        // System.out.println(test.method());
        System.out.println("面积为：" + test.method(10, 8));
    }

    // 1
    // public void method() {
    // for (int i = 0; i < 10; i++) {
    // for (int j = 0; j < 8; j++) {
    // System.out.print("* ");
    // }
    // System.out.println();
    // }
    // }
    // 2
    // public int method() {
    // for (int i = 0; i < 10; i++) {
    // for (int j = 0; j < 8; j++) {
    // System.out.print("* ");
    // }
    // System.out.println();
    // }
    // return 10 * 8;
    // }
    // 3
    public int method(int m, int n) {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
        return m * n;
    }
}

定义类Student，包含三个属性:学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一:打印出3年级(state值为3) 的学生信息。
问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示:
1) 生成随机数: Math.random(), 返回值类型double;
2) 四舍五入取整: Math.round(double d)，返回值类型long。

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

        // 声明 Student 类型的数组
        Student[] stus = new Student[20];
        for (int i = 0; i < stus.length; i++) {
            // 给数组元素赋值
            stus[i] = new Student();
            // 给 Student 对象属性赋值
            stus[i].number = i + 1;
            // 年级 [1，6]
            stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
            // 成绩 [0,100]
            stus[i].score = (int) (Math.random() * (100 - 0 + 1) + 1);
        }

        // 遍历学生数组
        for (int i = 0; i < stus.length; i++) {
            // System.out.println(stus[i].number);
            // System.out.println(stus[i].state);
            // System.out.println(stus[i].score);
            System.out.println(stus[i].info());
        }
        System.out.println("=============================");
        
        // 问题一:打印出3年级(state值为3) 的学生信息
        for (int i = 0; i < stus.length; i++) {
            if (stus[i].state == 3) {
                System.out.println(stus[i].info());
            }
        }
        System.out.println("=============================");
        
        // 问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息
        for (int i = 0; i < stus.length -1; i++) {
            for (int j = 0; j < stus.length -1; j++) {
                if(stus[j].score > stus[j+1].score){
                    Student temp = stus[j];
                    stus[j] = stus[j+1];
                    stus[j+1] = temp;
                }
            }
        }
        // 遍历学生数组
        for (int i = 0; i < stus.length; i++) {
            // System.out.println(stus[i].number);
            // System.out.println(stus[i].state);
            // System.out.println(stus[i].score);
            System.out.println(stus[i].info());
        }

    }
}

class Student {
    int number; // 学号
    int state; // 年级
    int score; // 成绩

    public String info() {
        return "学号：" + number + "\t  " + state + "年级\t成绩：" + score;
    }
}

将上题进一步优化

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

        // 声明 Student 类型的数组
        Student1[] stus = new Student1[20];
        for (int i = 0; i < stus.length; i++) {
            // 给数组元素赋值
            stus[i] = new Student1();
            // 给 Student 对象属性赋值
            stus[i].number = i + 1;
            // 年级 [1，6]
            stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
            // 成绩 [0,100]
            stus[i].score = (int) (Math.random() * (100 - 0 + 1));
        }
        
        StudentTest1 test = new StudentTest1();

        // 遍历学生数组
        test.print(stus);
        
        System.out.println("===========================");

        // 问题一:打印出3年级(state值为3) 的学生信息
        test.searchStats(stus, 3);
        
        System.out.println("===========================");

        // 问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息
        test.sort(stus);
        test.print(stus);


    }
    /**
     * 
     * @Description 遍历数组
     * @author xiaokai54
     * @param stus
     */
    
    public void print(Student1[] stus){
        for (int i = 0; i < stus.length; i++) {
            System.out.println(stus[i].info());
        }
    }
    /**
     * 
     * @Description 查找Student1 数组中指定年级的学生信息
     * @author xiaokai54
     * @param stus 要查找的数据
     * @param stats 要查找的年级
     */
    public void searchStats(Student1[] stus, int stats){
        for (int i = 0; i < stus.length; i++) {
            if (stus[i].state == stats) {
                System.out.println(stus[i].info());
            }
        }
    }
    /**
     * 
     * @Description 给Student1数组排序
     * @author xiaokai54
     * @param stus
     */
    public void sort(Student1[] stus){
        for (int i = 0; i < stus.length - 1; i++) {
            for (int j = 0; j < stus.length - 1; j++) {
                if (stus[j].score > stus[j + 1].score) {
                    Student1 temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }
            }
        }
    }
}

class Student1 {
    int number; // 学号
    int state; // 年级
    int score; // 成绩

    public String info() {
        return "学号：" + number + "\t  " + state + "年级\t成绩：" + score;
    }
}

方法的重载

重载的概念

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

重载的特点

与返回值类型无关，只看参数列表，且参数列表必须不同。（参数个数或参数类型）调用时，根据方法形参列表的不通来区别

练习

编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、-个字符串参数。
分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main ( )方法中分别用参数区别调用三个方法。
定义三个重载方法max( )，
第一个方法求两个int值中的最大值，
第二个方法求两个double值中的最大值，
第三个方法求三个double值中的最大值，
并分别调用三个方法。

public static void main(String[] args) {
    OverLoadExer test = new OverLoadExer();
    test.mOL(1);
    test.mOL(1, 2);
    test.mOL("小明");
}

// 1. 如下的三个方法构成重载
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);
}

// 2. 如下的三个方法构成重载
public int max(int i, int j) {
    return (i > j) ? i : j;
}

public double max(double b1, double b2) {
    return (b1 > b2) ? b1 : b2;
}

public double max(double b1, double b2, double b3) {
    return (b1 > b2) ? ((b1 > b3) ? b1 : b3) : ((b2 > b3) ? b2 : b3);
}

可变个数的形参

JavaSE 5.0 中提供了 Varargs(variable number of arguments) 机制，允许直接Dion工艺能和多个实参相匹配的形参，从而可以用一种更简单的方式，来传递个数可变的实参
具体使用
- 可变个数形参的格式：数据类型 ... 变量名
- 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，2个，……
- 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
- 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载（二者不能共存）
- 可变个数形参的方法中的形参中，必须声明在末尾
- 可变个数形参的方法中的形参中，最多只能声明一个可变形参

方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：
- 形参：方法声明时的参数
- 实参：方法调用时实际传给形参的参数值
Java 的实参值如何传入方法呢？
- Java 里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响
  - 形参时基本数据类型：将实参基本数据类型变量的 “数据值” 传递给参数
  - 形参时引用数据类型：将实参引用数据类型变量的 ”地址值“ 传递给参数

递归方法

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

构造器

构造器的作用

创建对象
初始化对象的信息

有关构造器的注意事项

如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式：权限修饰符类名(形参列表){}
一旦一个类中定义的多个构造器，彼此构成重载
所以但我们显式的定义了类的构造器之后，系统就不在提供默认的空参构造器
一个类中至少有一个构造器

练习

创建程序,在其中定义两个类：Person 和 PersonTest 类。
定义如下：用 setAge()设置人的合法年龄(0~130)，用 getAge()返回人的年龄。

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setAge(12);
        System.out.println("年龄为：" + p1.getAge());
    }
}
class Person {
    private int age;
    public void setAge(int a) {
        if (a < 0 || a > 130) {
            // throw new RuntimeException("传入的参数违法");
            System.out.println("传入的参数违法！！！");
            return;
        }
        age = a;
    }

    public int getAge() {
        return age;
    }
}

在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。\
修改上题中类和构造器，增加name属性，使得每次创建Person对象的同时初始化对象的age属性值和name属性

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setAge(12);
        System.out.println("年龄为：" + p1.getAge());
        Person p2 = new Person("TOM",21);
        System.out.println("name=" + p2.getName() + ",age=" + p2.getAge());
    }
}

class Person {
    private int age;
    private String name;

    public Person() {
        age = 18;
    }

    public Person(String n, int a) {
        name = n;
        age = a;
    }

    public void setAge(int a) {
        if (a < 0 || a > 130) {
            // throw new RuntimeException("传入的参数违法");
            System.out.println("传入的参数违法！！！");
            return;
        }
        age = a;
    }

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

编写两个类，TriAngle和TriAngleTest,其中TriAngle类中声明私有的底边长bas e和高height,同时声明公共方法访问私有变量。
此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。

public class TriAngleTest {

    public static void main(String[] args) {
        
        TriAngle t1 = new TriAngle();
        t1.setBase(2.0);
        t1.setHeight(2.5);
//        t1.base = 2.5;//The field TriAngle.base is not visible
//        t1.height = 4.3;        
        System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());
        
        TriAngle t2 = new TriAngle(5.1,5.6);
        System.out.println("面积 : " + t2.getBase() * t2.getHeight() / 2);

    }
}
class TriAngle {

    private double base;//底边长
    private double height;//高
    
    public TriAngle(){
        
    }
    
    public TriAngle(double b,double h){
        base = b;
        height = h;
    }
    
    public void setBase(double b){
        base = b;
    }
    
    public double getBase(){
        return base;
    }
    
    public void setHeight(double h){
        height = h;
    }
    
    public double getHeight(){
        return height;
    }
}

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

为什么需要封装？封装的作用和含义？
- 我们都需要洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结果吗？有必要碰电动机吗？
- 我要开车，……
我们程序设计追求“高内聚、低耦合”
- 高内聚：类的内部数据操作希捷自己完成，不允许外部干涉
- 低耦合：进队外暴露少量的方法用于使用
隐藏对象内的复杂度，之对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想

权限修饰符

Java 权限修饰符 public、protected、private 置于类的成员定义之前，用来限定对象对该类成员的访问权限

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes	-	-	-
(缺省)	yes	yes	-	-
protected	yes	yes	yes	-
public	yes	yes	yes	yes

对于 class 的权限修饰符之可以使用 public 和 default(缺省)
public 类可以在任何地方被访问
default 类只可以在被同一个包内部的类访问

信息的封装和隐藏

Java 中通过将数据声明为私有的 (private)，再提供公共的 (public) 方法：getXxx() 和 setXxx() 实现对该属性的操作，以实现以下目的：

隐藏一个类中不需要对外提供的实现细节；
使用者是能通过实现定制好的方法来访问数据，可以方便的加入控制逻辑，限制哦对属性的不合理操作；
便于修改，增强代码的可维护性

属性赋值的过程

默认初始化
显式初始化
构造器中赋值
通过 “对象.方法” 或 “对象.属性” 的方式赋值

验证过程

public class UserTest {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.age);// 1

        User u1 = new User(2);
        System.out.println(u1.age);// 2
        
        u1.setAge(3);
        System.out.println(u1.age);// 3
    }
}

class User {
    String name;
    int age = 1;

    public User() {

    }

    public User(int a) {
        age = a;
    }

    public void setAge(int a) {
        age = a;
    }
}

JavaBean 的使用

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

UML类图

表示 public 类型，-表示 private 类型，#表示 protected 类型
方法的写法: 方法的类型(+、-) 方法名(参数名：参数类型)：返回值类型

关键字1

this

什么是this

在 Java 中，this 关键字比较难理解，它的作用和其词义很接近
- 在方法内部使用，及这个方法所属对象的引用
- 它在构造器内部使用，表示该构造器正在初始化的对象
this 表示当前对象，可以嗲用类的属性、方法和构造器
什么时候使用 this 关键字
- 当在方法内需要用到调用该方法的对象时，就用 this
  具体的：我们可以用 this 来区分局部变量和属性
  比如：this.name = name;

package

为了更好实现项目中的管理，提供包的概念
使用 package 声明类或接口所属的包，声明在源文件的首行
包，属于标识符，遵循标识符的命名规范、规范(xxxyyyzzz)、“见名知意”
每“.”一次，就代表一层文件目录

同一个包下，不能命名同名的接口、类
不同的包下，可以命名同名的接口、类

MVC设计模式

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

模型层 model 主要处理数据

数据对象封装 model.bean/domain
数据库操作类 model.dao
数据库 model.db

视图层 view 显示数据

相关工具类 view.utils
自定义view view.ui

控制层 controller 处理业务逻辑

应用界面相关 controller.activity
存放 fragment controller.fragment
显式列表的适配器 controller.adapter
服务相关的 controller.servise
抽取的基类 controller.base

import

在原文件中显式的使用 import 结构导入指定包下的类、接口
声明在包的声明和类的声明之间
如果需要导入多个结构，则并列写出即可
如果使用“xxx.*”的方式，表示可以导入 xxx 包下的所有结构
如果使用的类或接口是 java.lang 包下定义的，则可以省略 import 结构
如果使用的类或接口是本包下定义的，则可以省略 import 结构
如果在源文件中，使用了不同包下的同名类，则必须至少有一个类需要以全类名的方式显示
使用“xxx.*”方式表明嗲用 xxx 包下的所有结构。但是如果使用的是 xxx 子包下的结构，则人需要显式导入
import static：导入指定类或接口的静态结构

面向对象特征之二：继承性

为什么要有继承
- 多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无需再定义这些属性和行为。只要继承那个类即可
此处的多个类称为子类（派生类），单独的这个类称为父类（基类或超类）。可以理解为”子类 is a 父类“
类继承语法规则：class A extends B{}
子类继承了父类，就继承了父类的方法和属性
在子类中，可以使用父类中顶一个方法和属性，也可以创建新的数据和方法
在 Java 中，继承的关键字是”extends“，即子类不是父类的子集，而是对父类的”扩展“

子类不能直接访问父类中私有的 (private) 成员变量和方法

Java中有关继承的规定

一个类可以被多个子类继承
Java 中类的单继承性：一个类只能由一个父类
子父类是相对的概念
子类直接继承的父类，称为：直接父类。间接继承的父类，称为：间接父类
子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

方法的重写

定义：在子类中可以根据需要从父类中继承离开的方法进行改造，可称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法
要求：
1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
  - 子类不能重现父类声明为 private 权限的方法
4. 子类方法抛出的异常不能大于父类被重写方法的异常
注意：
子类与父类中同名同参数的方法必须同时声明为非 static 的（即为重写），或者同时声明为 static 的（不是重写）。因为 static 方法是属于类的，子类无法覆盖父类的方法

关键字2

super

super 理解为：父类的……
super 可以来调用：属性、方法、构造器
super 的使用
- 我们可以在子类的方法或构造器中。使用 “super.属性” 或 “super.方法” 的方式，显式的调用父类中声明的属性或方法。但是在通常情况下，我们习惯省略 “super.”
- 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性时，则必须显式的使用 “super.属性” 的方式，表明调用的时父类中声明的属性
- 特殊情况：当子类重写了父类的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用 “super.方法” 的方式，表明调用的时父类中被重写的方法
super 调用构造器
- 我们可以在子类的构造器中显式的使用“super(形参列表)”的方式，调用父类中声明的指定的构造器
- “super(形参列表)” 的使用，必须声明在子类构造器的首行
- 我们在类的构造器中，针对于 “this(形参列表)” 或 “super(形参列表)” 只能二选一，不能同时出现
- 在构造器的首行，没有显式的声明 “this(形参列表)” 或 “super(形参列表)”，则默认调用的是父类中空参的构造器：super()
- 在类的多个构造器中，至少有一个类的构造器使用了 “super(形参列表)”，调用父类中的构造器

子类对象实例化的全过程

从结果上来看：(继承性)
- 子类继承父类以后，就获取了父类中声明的属性或方法
- 创建子类的对象，在堆空间中，就回家再所有父类中声明的属性
从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器直到调用了java.long.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才能可以看到内存中有父类中的结构，子类对象才可以考虑进行调用

虽然创建子类对象时，调用了父类的构造器，但自始至终就创建过一个对象，即为 new 的子类对象

面向对象特征之三：多态性

多态性，是面向对象中最重要的概念，在 Java 中体现：
对象的多态性：父类的引用指向子类的对象
- 可以直接应用在抽象类和接口上
Java 引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时引用的类型决定，运行时类型由实际赋给变量的对象决定。简称：编译时，看左边；运行时看右边
- 若编译时类型和运行时类型不一致时，就出现了对象的多态性（Polymorphism）
- 多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
  ”看右边“：看的时子类的对象（实际运行的时子类重写父类的方法）

虚拟方法调用

Virtual Method Invocation

正常方法调用

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用（多态情况下）
子类中顶一个与父类同名同参的方法，在多态情况下，将此父类的方法称为虚拟方法，父类根据赋给它的不同子类的对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的

Person e = new Student();
e.getInfo();// 调用 Student 类的 getInfo() 方法

编译时类型和运行时类型
编译时 e 为 Person 类型，而方法调用实在运行时确定的，所以调用的是 Student 类的 getInfo() 方法— 动态绑定

方法的重载和重写：
一、二者定义细节：
略
二、从编译和运行的角度看：
重载，是指运存存在多个方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名的方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java 的重载是可以包括父类和子类的，及子类可以重载父类的同命不同参的方法
所以，对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这成为 "早绑定" 或 “静态绑定”
而对于多态，只有等到一个方法调用的那一刻，编译器才会确定索要调用的具体方法，这成为 “晚绑定” 或 ”动态绑定“
引用 Bruce Eckel 的话：“不要犯傻，如果它不是晚绑定，它就不是多态”

instanceof 操作符

x instanceof A：检验 x 是否为类 A 的对象，返回值为 boolean 型

要求 x 所属的类与类 A 必须是子类和父类的关系，否则编译错误
如果 x 属于类 A 的子类 B x instanceof A 也为 true

Object 类的使用

Object 类是所有 Java 类的根父类
如果在类的声明中未使用 extends 关键字指明其父类，则默认父类为 java.lang .Object 类
```
public class Person{
    
}
```
等价于
```
public class Person extends Object{
    
}
```

Object 类总的主要结构

NO.	方法名称	类型	描述
1	Public Object()	构造	构造器
2	Public boolean equals(Object obj)	普通	对象比较
3	public int hashCode()	普通	取得 Hash 码
4	public String toString()	普通	对象打印时调用

重写 equals()方法的原则

对称性：如果 x.equals(y) 返回 “true”，那么 y.equals(x) y 也应该返回 ”true“
自反性：x.equals(x) 必须返回 ”true“
传递性：如果 x.equals(y) 返回 ”true“，而且 y.equals(z) 返回 ”true“，那么 z.equals(x) 也应该返回 ”true“
一致性：如果 x.equals(y) 返回 ”true"，只要 x 和 y 的内容一直不变，不管你重复 x.equals(y) 多少次，返回都是”true“
任何情况下，x.equals(null) 永远返回 “false“；
x.equals(和 x 不同类型的对象) 永远返回 “false“

面试题：== 和 equals 的区别

== 既可以比较基本数据类型也可以比较引用数据类型，对于基本数据类型就是比较值，对于引用数据类型就是比较内存地址
equals 的话，它是属于 java.lang.Object 类里的方法，如果该方法没有被重写过默认也是 ==；我们可以看到 String 等类的 equals 方法是被重写过的，而且 String 类在日常开法中使用的比较多，久而久之，形成了 equals 是比较值的错误观点
具体要看自定义类里有没有重写 Object 的 equals 方法来判断
通常情况下，重写 equals 方法，会比较类中的相应属性是否都相等

toString()

toString() 方法在 Object 类中定义，其返回值是 String 类型，返回类名和他的引用地址

在进行 String 与其它类型数据的连接操作是，自动发调 toString() 方法

Date now = new Date();
System.out.println("now=" + now);// 相当于
System.out.println("now=" + now.toString());

可以根据需要在用户自定义类型中重写 toString() 方法
如 String 类中重写了 toString() 方法，返回字符串的值
```
s1 = "hello";
System.out.println(s1)// 相当于
System.out.println(s1.toString())
```
基本类型数据转换为 String 类型时，调用了对应包装类的 toString() 方法
```
int a= 10;
System.out.println("a=" + a);
```

Eclipse单元测试

Java 中的 JUnit 单元测试

步骤：
1. 选中当前工程 - 右键选择：build path => add libraries => JUnit4 => 下一步
2. 创建 Java 类，进行单元测试
  此时的 Java 类要求：
  ① 此类是 public 的
  ② 此类提供无参的构造器
3. 此类中声明单元测试方法
  此类的单元测试方法：方法的权限是public，没有返回值，没有形参
4. 此单元测试方法上需要声明注解：@Test，并在单元测试类中导入：import org.junit.Test;
5. 声明号单元测试方法后，就可以在方法体内测试相关的代码
6. 写完测试代码后，左键双击单元测试方法名，右键：run as - JUnit Test
说明：
1. 如果执行结果没有任何异常：绿条
2. 如果执行结果出现异常：红条

包装类

针对八种基本数据类型的定义相应的引用方法 - 包装类（封装类）
有了类的特点，就可以调用类中的方法，Java 才是真正的面向对象

包装类与基本数据类型相互转换

import org.junit.Test;

/*
 * 包装类的使用：
 * 1. Java提供了八种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
 * 
 * 2. 基本数据类型、包装类、String三者之间的转换
 */
public class WrapperTest {

    // String 类型 => 基本数据类型、包装类：调用包装类的 parseXxx(String s)
    @Test
    public void test5() {
        String str1 = "123";
        // int num1 = (int)str1;
        // Integer in1 = (Integer)str1;
        int num2 = Integer.parseInt(str1);
        System.out.println(num2 + 1);
        
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);
    }

    // 基本数据类型、包装类 => String 类型：调用String重载的valueOf(Xxx xxx)
    @Test
    public void test4() {
        int num1 = 10;
        // 方式一：连接运算
        String str1 = num1 + "";
        // 方式二：
        float f1 = 12.3f;
        String str2 = String.valueOf(f1);// "12.3"

        Double d1 = new Double(12.4);
        String str3 = String.valueOf(d1);
        System.out.println(str2);
        System.out.println(str3);// "12.4"

    }

    // JDK 5.0新特性：自动装箱与开箱
    @Test
    public void test3() {
        // int num1 = 10;
        // 基本数据类型 -> 包装类的对象
        // method(num1);

        // 自动装箱：基本数据类型 => 包装类
        int num2 = 10;
        Integer in1 = num2;// 自动装箱

        boolean b1 = true;
        Boolean b2 = b1;// 自动装箱

        // 自动拆箱：包装类 => 基本数据类型
        System.out.println(in1.toString());

        int num3 = in1;// 自动拆箱
    }

    public void method(Object obj) {
        System.out.println(obj);
    }

    // 包装类 => 基本数据类型:调用包装类的xxxValue()
    @Test
    public void test2() {
        Integer in1 = new Integer(12);
        int i1 = in1.intValue();
        System.out.println(i1 + 1);

        Float f1 = new Float(12.3);
        float f2 = f1.floatValue();
        System.out.println(f1 + 1);
    }

    // 基本数据类型 => 包装类：调用包装类的构造器
    @Test
    public void test1() {
        int num1 = 10;
        Integer in1 = new Integer(num1);
        System.out.println(in1.toString());

        Integer in2 = new Integer("123");
        System.out.println(in2.toString());

        // 报异常
        // Integer in3 = new Integer("123abc");
        // System.out.println(in2.toString());

        Float f1 = new Float(12.3f);
        Float f2 = new Float("12.3");
        System.out.println(f1);
        System.out.println(f2);

        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("TrUe");
        System.out.println(b2);
        Boolean b3 = new Boolean("true123");
        System.out.println(b3);// false

        Order order = new Order();
        System.out.println(order.isMale);// false
        System.out.println(order.isFemale);// null
    }
}

class Order {
    boolean isMale;
    Boolean isFemale;

}

面试题

如下两个题目输出结果相同吗？各是什么？

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);

Object o2;
if (true)
    o2 = new Integer(1);
else
    o2 = new Double(2.0);
System.out.println(o2);

1.0
1

执行如下代码后输出结果如何？

public void method () {
    Integer i = new Integer(1);
    Integer j = new Integer(1);
    System.out.println(i == j);

    Integer m = 1;
    Integer n = 1;
    System.out.println(m == n);

    Integer x = 128;
    Integer y = 128;
    System.out.println(x == y);
}

false
true
false

练习

利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级。
提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。而向量类java.util.Vector可以根据需要动态伸缩。
创建Vector对象：Vector v = new Vector();
给向量添加元素：v.addElement(Object obj); //obj必须是对象
取出向量中的元素：Object obj = v.elementAt(0);
注意第一个元素的下标是0，返回值是Object类型的。
计算向量的长度：v.size();
若与最高分相差
    10分内：A等；
    20分内：B等；
    30分内：C等；
    其它：D等

public class VectorTest {
    public static void main(String[] args) {
        // 1. 实例化Scanner，用于从键盘获取学生成绩
        Scanner scan = new Scanner(System.in);

        // 2. 创建 Vector 对象：Vector v = new Vector();相当于原来的数组
        Vector v = new Vector();

        // 3. 通过for(;;)或while(true)方式，给 Vector 中添加数组
        int maxScore = 0;
        for (;;) {
            System.out.println("请输入学生成绩（以负数在表输入结束）");
            int score = scan.nextInt();
            // 3.2 当输入的是负数时，跳出循环
            if (score < 0) {
                break;
            }
            if (score > 100) {
                System.out.println("输入的数值非法，请重新输入：");
                continue;
            }
            // 3.1 添加操作：v.addElement(Object obj);
            // JDK5.0之前
            // Integer inScore = new Integer(score);
            // v.addElement(inScore);// 多态
            // JDK5.0之后
            v.addElement(score);
            // 4. 获取学生成绩最大值
            if (maxScore < score) {
                maxScore = score;
            }
        }

        // 5. 遍历 Vector，得到每个学生成绩，并于最大成绩比较，得到每个学生的等级
        char level;
        for (int i = 0; i < v.size(); i++) {
            Object obj = v.elementAt(i);
            // JDK5.0之前
            // Integer inScore = (Integer)obj;
            // int score = inScore.intValue();
            // JDK5.0之后
            int score = (int) obj;

            if (maxScore - score <= 10) {
                level = 'A';
            } else if (maxScore - score <= 20) {
                level = 'B';
            } else if (maxScore - score <= 30) {
                level = 'C';
            } else {
                level = 'D';
            }
            System.out.println("student-" + i + " score is " + score + " level is " + level);

        }
    }
}

关键字3

static

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过 new 关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都由个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中单独分配一个用于代表国家名称的变量

static 可以用来修饰：属性、方法、代码块、内部类
使用 static 修饰属性：静态变量
- 属性，按是否使用 static 修饰，又分为：静态属性 vs 非静态属性（实例变量）
  实例变量：我们创建了类的多个对象，每个对象被都独立的拥有一套类中的非静态属性。当修改齐总一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改
  静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的
- static 修饰属性的其他说明：
  1. 静态变量随着类的加载而加载
  2. 静态变量的加载要早于对象的创建
  3. 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法去的静态域中
  4. | | 类变量 | 实例变量 |
    | :--: | :----: | :------: |
    | 类 | yes | no |
    | 对象 | yes | yes |
- 静态属性举例：System.out; Math.PI
使用 static 修饰方法：静态方法
1. 随着类的加载而加载，可以通过"类.静态方法"调用
2. | | 静态方法 | 非静态方法 |
  | :--: | :------: | :--------: |
  | 类 | yes | no |
  | 对象 | yes | yes |
3. 静态方法中，只能调用静态方法或属性
  非静态方法中，既可以调用非静态方法或属性，也可以调用静态的方法或属性
static 注意点：
- 在静态方法内，不能使用 this 关键字、super 关键字
- 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解
开发中，如何确定一个属性是否要声明为 static ？
- 属性可以被多个对象所共享的，不会随着对象的不同而不同的
- 类中的常量也常常声明为 static
开发中，如何确定一个方法是否要声明为 static ?
- 操作静态属性的方法，通常设置为 static 的
- 工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

public class StaticTest {
    public static void main(String[] args) {
        Chinese c1 = new Chinese();
        c1.name = "姚明";
        c1.age = 40;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "马龙";
        c2.age = 35;

        c2.nation = "CHINA";

        System.out.println(c2.nation);
        System.out.println(c1.nation);

        // 编译不通过
        // Chinese.name = "张继科";

        c1.eat();

        Chinese.show();

        // 编译不通过
        // Chinese.eat();
    }
}

// 中国人
class Chinese {
    String name;
    int age;
    static String nation;

    public void eat() {
        System.out.println("恰饭");
        // 调用非静态结构
        this.info();
        System.out.println("name:" + name);
        // 调用静态结构
        walk();
        System.out.println("nation:" + Chinese.nation);
    }

    public static void show() {
        System.out.println("中国人不骗中国人！");
        // 不能调用非静态结构
        // eat();
        // name = "Tom";
        // 可以调用静态的结构
        System.out.println(Chinese.nation);
        walk();
    }

    public void info() {
        System.out.println("name:" + name + ",age:" + age);
    }

    public static void walk() {

    }
}

单例设计模式

设计模式是在大量的实践中综合和理论话之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像经典的棋谱，不同的棋局，我们用不同的棋谱，免去哦我们自己再思考和摸索。“套路“
所谓的单例设计模式，就是采取一定的方法保证再整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类再一个虚拟机中只产生一个对象，我们首先必须将类的构造器的访问权限设置为 private，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为再类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的

饿汉式单例模式的实现

public class SingLetonTest1 {
    public static void main(String[] args) {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        
        System.out.println(bank1 == bank2);
    }
}
class Bank {
    // 1. 私有化类的构造器
    private Bank() {

    }

    // 2. 内部创建类的对象
    // 4. 要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    // 3. 提供公共的静态的方法，返回类的对象
    public static Bank getInstance() {
        return instance;
    }
}

懒汉式单例模式的实现

public class SingLetonTest2 {
    public static void main(String[] args) {
        Order o1 = Order.getInstance();
        Order o2 = Order.getInstance();
        
        System.out.println(o1 == o2);
    }
}
class Order{
    // 1. 私有化类的构造器
    private Order(){
        
    }
    
    // 2. 声明当前类对象，没有初始化
    // 4. 此对象也必须声明为static
    private static Order instance = null;
    
    // 3. 声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if (instance == null){
            instance = new Order();
        }
        return instance;
    }
}

单例设计模式的应用场景

网站的计数器，一般也是单例模式实现，否则难以同步
应用程序的日志应用，一般都是用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加
数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源
项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取
Application 也是单例的典型应用
Windows 的 Task Manager (任务管理器) 就是典型的单例模式
Windows 的 Recycle Bin (回收站) 也是典型的单例应用。在整个系统运行过程中，回收站一直维护者仅有的一个实例

类变量 vs 实例变量内存解析

理解main方法的语法

main()方法作为程序的入口
main()方法也是一个普通的静态方法
main()方法也可以作为我们与控制台交互的方式。(之前，使用 Scanner)

public class MainDemo {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("===" + args[i]);
            
            int num = Integer.parseInt(args[i]);
            System.out.println("====" + num);
        }
    }
}

控制台编译 javac MainDemo.java
运行 java Main "12" "23"
输出结果

===12
====12
===23
====23

类的成员之四-代码块

代码块的作用：用来初始化类、对象
代码块如果有修饰的话，只能使用static
静态代码块
- 内部可以有输出语句
- 随着类的加载而执行，而且只执行一次
- 作用：初始化类的信息
- 如果一个类中顶一个多个静态代码块，则按照声明的先后顺序执行
- 静态代码块的执行要优于非静态代码块的执行
- 静态代码块只能调用静态的属性、静态的方法，不能调用非静态的结构
非静态代码块
- 内部可以有输出语句
- 随着对象的创建而执行
- 每创建一个对象，就执行一次非静态代码块
- 作用：可以在创建对象时，对对象的属性等进行初始化
- 如果一个类中顶一个多个非静态代码块，则按照声明的先后顺序执行
- 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

public class BlockTest {
    public static void main(String[] args) {
        String desc = Person.desc;
        System.out.println(Person.desc);

        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1.age);

        Person.info();
    }
}

class Person {
    // 属性
    String name;
    int age;
    static String desc = "我是一个人";

    // 构造器
    public Person() {

    }

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

    // static的代码块
    static {
        System.out.println("hello, static block -1");
        // 调用静态结构
        desc = "Person";
        info();
        // 不可以调用非静态结构
        // eat();
        // name = "Tom";
    }
    static {
        System.out.println("hello, static block -2");
    }

    // 非static的代码块
    {
        System.out.println("hello, block -1");
        // 调用非静态结构
        age = 1;
        eat();
        // 调用静态结构
        desc = "我是一个正在学习Java的人";
        info();
        
    }
    {
        System.out.println("hello, block -2");
    }

    // 方法
    public void eat() {
        System.out.println("吃饭");
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    public static void info() {
        System.out.println("I am a heppy boy");
    }
}

输出结果

hello, static block -1
heppy boy
hello, static block -2
Person
hello, block -1
吃饭
heppy boy
hello, block -2
hello, block -1
吃饭
heppy boy
hello, block -2
1
heppy boy

练习

如下代码执行后输出内容是什么

class Root {
    static {
        System.out.println("Root的静态初始化快");
    }
    {
        System.out.println("Root的普通初始化快");
    }

    public Root() {
        super();
        System.out.println("Root的无参数构造器");
    }
}

class Mid extends Root {
    static {
        System.out.println("Mid的静态初始化快");
    }
    {
        System.out.println("Mid的普通初始化快");
    }

    public Mid() {
        super();
        System.out.println("Mid的无参数构造器");
    }

    public Mid(String msg) {
        // 通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值：" + msg);
    }
}

class Leaf extends Mid {
    static {
        System.out.println("Leaf的静态初始化快");
    }
    {
        System.out.println("Leaf的普通初始化快");
    }

    public Leaf() {
        // 通过super调用父类中有一个字符串参数的构造器
        super("中国");
        System.out.println("Leaf的无参数构造器");
    }
}

public class LeafTest {
    public static void main(String[] args) {
        new Leaf();
        System.out.println();
        new Leaf();
    }
}

输出内容：

Root的静态初始化快
Mid的静态初始化快
Leaf的静态初始化快
Root的普通初始化快
Root的无参数构造器
Mid的普通初始化快
Mid的无参数构造器
Mid的带参数构造器，其参数值：中国
Leaf的普通初始化快
Leaf的无参数构造器

Root的普通初始化快
Root的无参数构造器
Mid的普通初始化快
Mid的无参数构造器
Mid的带参数构造器，其参数值：中国
Leaf的普通初始化快
Leaf的无参数构造器