Java基础：面向对象

1. 面向对象思想

1.1 面向对象思想引入

前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？通过前面的讲解我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。

1.2 面向过程思想概述

我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。

在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。

那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

面向过程的代表语言：C语言，强调的是每一个功能的步骤

1.3 面向对象思想概述

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。接下来我们看看面向对象到底是什么?

面向对象思想概述：面向对象是基于面向过程的编程思想，强调的是对象，然后由对象去调用功能。

面向对象思想特点

  • 是一种更符合我们思想习惯的思想
  • 可以将复杂的事情简单化
  • 将我们从执行者变成了指挥者，角色发生了转换

举例：

(1) 买电脑：
​
面向过程：我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑

面向对象：我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了

(2) 洗衣服：

面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来

面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来

(3) 吃饭：

面向过程：去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃

面向对象：上饭店吃饭，你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃

1.4 面向对象开发，设计，特征

面向对象开发：就是不断的创建对象，使用对象，指挥对象做事情。
面向对象设计：其实就是在管理和维护对象之间的关系。

面向对象特征

  • 封装(encapsulation)
  • 继承(inheritance)
  • 多态(polymorphism)

2. 类与对象及其使用

2.1 类与对象的关系

我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。

我们如何表示一个现实世界事物呢：

  • 属性 就是该事物的描述信息
  • 行为 就是该事物能够做什么
  • 举例：学生事物

我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。

类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
举例：类 学生，对象班长就是一个对象

PS
类：可以理解为构造对象的一个蓝图或者模版，是抽象的概念
对象：是以类为模型创建的具体实例，是对类的一种具体化。

2.2 类的定义

现实世界的事物有属性（人的身高，体重等）和行为（人可以学习，吃饭等）

Java中用class描述事物也是如此，成员变量 就是事物的属性，成员方法 就是事物的行为

定义类其实就是定义类的成员(成员变量和成员方法)

/**
    事物：
        属性  事物的信息描述
        行为  事物的功能
    
    类：
        成员变量    事物的属性
        成员方法    事物的行为
        
    定义一个类，其实就是定义该类的成员变量和成员方法。
    
    案例：我们来完成一个学生类的定义。
    
    学生事物：
        属性：姓名，年龄，地址...
        行为：学习，吃饭，睡觉...
        
    把事物要转换为对应的类：
    
    学生类：
        成员变量：姓名，年龄，地址...
        成员方法：学习，吃饭，睡觉...
        
    成员变量：和以前变量的定义是一样的格式，但是位置不同，在类中方法外。
    成员方法：和以前的方法定义是一样的格式，但是今天把static先去掉。
    
    首先我们应该定义一个类，然后完成类的成员。
*/
//这是我的学生类
class Student {
    //定义变量
    String name;//姓名
    int age;//年龄
    String address;//地址
    
    //定义方法
    //学习的方法
    public void study() {
        System.out.println("学生爱学习");
    }
    
    //吃饭的方法
    public void eat() {
        System.out.println("学习饿了,要吃饭");
    }
    
    //睡觉的方法
    public void sleep() {
        System.out.println("学习累了,要睡觉");
    }
}

2.3 对象内存图

1个对象的内存图：一个对象的基本初始化过程

java对象内存

2个对象的内存图：方法的共用

java对象内存

3个对象的内存图：其中有两个引用指向同一个对象

java对象内存

2.4 成员变量和局部变量的区别

成员变量和局部变量的区别

注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

class Varialbe {
    //成员变量
    //int num = 10;
    int num; //0
    
    public void show() {
        //int num2 = 20; //局部变量
        //可能尚未初始化变量num2
        //int num2; //没有默认值
        int num2 = 20;
        System.out.println(num2);
        
        //int num = 100;
        System.out.println(num);
    }
}

class VariableDemo {
    public static void main(String[] args) {
        Varialbe v = new Varialbe();
        
        System.out.println(v.num); //访问成员变量
        
        v.show();   
            
    }
}

2.5 形式参数问题

基本类型作为形式参数：形式参数的改变不影响实际参数
引用类型作为形式参数：形式参数的改变直接影响实际参数

/**
    形式参数的问题：
        基本类型：形式参数的改变不影响实际参数
        引用类型：形式参数的改变直接影响实际参数
*/
//形式参数是基本类型
class Demo {
    public int sum(int a,int b) {
        return a + b;
    }
}

//形式参数是引用类型
class Student {
    public void show() {
        System.out.println("我爱学习");
    }
}

class StudentDemo {
    //如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
    public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
        s.show();
    }
}

class ArgsTest {
    public static void main(String[] args) {
        //形式参数是基本类型的调用
        Demo d = new Demo();
        int result = d.sum(10,20);
        System.out.println("result:"+result);
        System.out.println("--------------");
        
        //形式参数是引用类型的调用
        //需求：我要调用StudentDemo类中的method()方法
        StudentDemo sd = new StudentDemo();
        //创建学生对象
        Student s = new Student();
        sd.method(s); //把s的地址给到了这里
    }
}

运行结果：

形参

2.6 匿名对象

匿名对象：就是没有名字的对象。是对象的一种简化表示形式
匿名对象的两种使用情况：对象调用方法仅仅一次的时候；作为实际参数传递。

/**
    匿名对象：就是没有名字的对象。
    
    匿名对象的应用场景：
        A:调用方法，仅仅只调用一次的时候。
            注意：调用多次的时候，不适合。
            那么，这种匿名调用有什么好处吗?
                有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
        B:匿名对象可以作为实际参数传递
*/
class Student {
    public void show() {
        System.out.println("我爱学习");
    }
}

class StudentDemo {
    public void method(Student s) {
        s.show();
    }
}

class NoNameDemo {
    public static void main(String[] args) {
        //带名字的调用
        Student s = new Student();
        s.show();
        s.show();
        System.out.println("--------------");
        
        //匿名对象
        //new Student();
        //匿名对象调用方法
        new Student().show();
        new Student().show(); //这里其实是重新创建了一个新的对象
        System.out.println("--------------");
        
        
        //匿名对象作为实际参数传递
        StudentDemo sd = new StudentDemo();
        //Student ss = new Student();
        //sd.method(ss); //这里的s是一个实际参数
        //匿名对象
        sd.method(new Student());
        
        //在来一个
        new StudentDemo().method(new Student());
    }
}

运行结果：

匿名对象

2.7 封装(private)

封装概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装的好处：

  • 隐藏实现细节，提供公共的访问方式
  • 提高了代码的复用性
  • 提高安全性。

封装原则：

  • 将不需要对外提供的内容都隐藏起来。
  • 把属性隐藏，提供公共方法对其访问。

private关键字：

  • 是一个权限修饰符。
  • 可以修饰成员(成员变量和成员方法)
  • 被private修饰的成员只在本类中才能访问。

private最常见的应用：

  • 把成员变量用private修饰
  • 提供对应的getXxx()/setXxx()方法
  • 一个标准的案例的使用
/**
    封装和private的应用：
        A:把成员变量用private修饰
        B:提高对应的getXxx()和setXxx()方法
*/
//定义学生类
class Student {
    //姓名
    private String name;
    //年龄
    private int age;
    
    //姓名获取值
    public String getName() {
        return name;
    }
    
    //姓名设置值
    public void setName(String n) {
        name = n;
    }
    
    //年龄获取值
    public int getAge() {
        return age;
    }
    
    //年龄赋值
    public void setAge(int a) {
        age = a;
    }
}

//测试类
class StudentTest {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        
        //使用成员变量
        //错误：被私有修饰了，外界不能直接访问了
        //System.out.println(s.name+"---"+s.age);
        System.out.println(s.getName()+"---"+s.getAge());
        
        //给成员变量赋值
        //s.name = "林青霞";
        //s.age = 27;
        //通过方法给赋值
        s.setName("林青霞");
        s.setAge(27);
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

运行结果：

private关键字

2.8 this关键字

this：代表所在类的对象引用
记住：方法被哪个对象调用，this就代表那个对象

什么时候使用this呢?

  • 局部变量隐藏成员变量
  • 其他用法后面和super一起讲解
/** 
    我们曾经曰：起名字要做到见名知意。
    
    this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。
    
        注意：谁调用这个方法，在该方法内部的this就代表谁。
        
    this的场景：
        解决局部变量隐藏成员变量
    
    this:哪个对象调用那个方法，this就代表那个对象
*/
class Student {
    private String name;
    private int age;
    
    public String getName() {
        return name; //这里其实是隐含了this
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

class StudentTest2 {
    public static void main(String[] args) {
        //创建一个对象
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(27);
        System.out.println(s1.getName()+"---"+s1.getAge());
        
        //创建第二个对象
        Student s2 = new Student();
        s2.setName("刘意");
        s2.setAge(30);
        System.out.println(s2.getName()+"---"+s2.getAge());
    }
}

运行结果：

this关键字

this关键字的内存图解：

this关键字

2.9 构造方法

构造方法作用概述：给对象的数据进行初始化

构造方法格式

  • 方法名与类名相同
  • 没有返回值类型，连void都没有
  • 没有具体的返回值

构造方法注意事项

  • 如果你不提供构造方法，系统会给出默认构造方法
  • 如果你提供了构造方法，系统将不再提供
  • 构造方法也是可以重载的

给成员变量赋值有两种方式：

  • setXxx()
  • 构造方法

PS：
1、一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用并且只调用一次。
一般函数：对象创建后，可以被调用多次。

2、创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

3、多个构造函数是以重载的形式存在的。

/**
    我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?
    
    构造方法的注意事项:
        A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
        B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
            注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
        
    给成员变量赋值有两种方式：
        A:setXxx()
        B:构造方法
*/

class Student {
    private String name;
    private int age;

    public Student() {
        //System.out.println("我给了，你还给不");
        System.out.println("这是无参构造方法");
    }
    
    //构造方法的重载格式
    public Student(String name) {
        System.out.println("这是带一个String类型的构造方法");
        this.name = name;
    }
    
    public Student(int age) {
        System.out.println("这是带一个int类型的构造方法");
        this.age = age;
    }
    
    public Student(String name,int age) {
        System.out.println("这是一个带多个参数的构造方法");
        this.name = name;
        this.age = age;
    }
    
    public void show() {
        System.out.println(name+"---"+age);
    }
}

class ConstructDemo2 {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
        System.out.println("-------------");
        
        //创建对象2
        Student s2 = new Student("林青霞");
        s2.show();
        System.out.println("-------------");
        
        //创建对象3
        Student s3 = new Student(27);
        s3.show();
        System.out.println("-------------");
        
        //创建对象4
        Student s4 = new Student("林青霞",27);
        s4.show();
    }
}

2.10 类的成员方法

成员方法其实就是我们前面讲过的方法

方法具体划分：

  • 根据返回值：有明确返回值方法；返回void类型的方法
  • 根据形式参数：无参方法；带参方法

一个基本类的标准代码写法

/**
    一个标准代码的最终版。
    
    学生类：
        成员变量：
            name，age
        构造方法：
            无参，带两个参
        成员方法：
            getXxx()/setXxx()
            show()：输出该类的所有成员变量值
            
    给成员变量赋值：
        A:setXxx()方法
        B:构造方法
        
    输出成员变量值的方式：
        A:通过getXxx()分别获取然后拼接
        B:通过调用show()方法搞定
*/
class Student {
    //姓名
    private String name;
    //年龄
    private int age;
    
    //构造方法
    public Student() {
    }
    
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    //输出所有的成员变量值
    public void show() {
        System.out.println(name+"---"+age);
    }
}

//测试类
class StudentTest {
    public static void main(String[] args) {
        //方式1给成员变量赋值
        //无参构造+setXxx()
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(27);
        //输出值
        System.out.println(s1.getName()+"---"+s1.getAge());
        s1.show();
        System.out.println("----------------------------");
        
        //方式2给成员变量赋值
        Student s2 = new Student("刘意",30);
        System.out.println(s2.getName()+"---"+s2.getAge());
        s2.show();
    }
}

运行结果：

类的成员方法

2.11 类的初始化过程

Student s = new Student();在内存中做了哪些事情?

  • 加载Student.class文件进内存
  • 在栈内存为s开辟空间
  • 在堆内存为学生对象开辟空间
  • 对学生对象的成员变量进行默认初始化
  • 对学生对象的成员变量进行显示初始化
  • 通过构造方法对学生对象的成员变量赋值
  • 学生对象初始化完毕，把对象地址赋值给s变量
类的初始化过程

2.12 static关键字

static关键字可以修饰成员变量和成员方法

static关键字特点

  • 随着类的加载而加载
  • 优先于对象存在
  • 被类的所有对象共享
  • 这也是我们判断是否使用静态关键字的条件
  • 可以通过类名调用

static关键字注意事项

  • 在静态方法中是没有this关键字的
  • 静态方法只能访问静态的成员变量和静态的成员方法

静态的内存图

静态的内存图

静态变量和成员变量的区别

静态变量和成员变量的区别

2.13 main方法是静态的

public static void main(String[] args) {}

  • public 被jvm调用，访问权限足够大。
  • static 被jvm调用，不用创建对象，直接类名访问
  • void被jvm调用，不需要给jvm返回值
  • main 一个通用的名称，虽然不是关键字，但是被jvm识别
  • String[] args 以前用于接收键盘录入的
  • 静态什么时候用？

静态变量

当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。

只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

静态函数

函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。

简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用。

如果没有访问特有数据的方法，该对象的创建是没有意义。

/*
    main方法的格式讲解：
        public static void main(String[] args) {...}
        
        public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
        static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
        void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
        main:是一个常见的方法入口。我见过的语言都是以main作为入口。
        String[] args:这是一个字符串数组。值去哪里了?
            这个东西到底有什么用啊?怎么给值啊?
                这个东西早期是为了接收键盘录入的数据的。
                格式是：
                    java MainDemo hello world java
*/
class MainDemo {
    public static void main(String[] args) {
        //System.out.println(args); //[Ljava.lang.String;@175078b
        //System.out.println(args.length); //0
        //System.out.println(args[0]); //ArrayIndexOutOfBoundsException
        
        //接收数据后
        System.out.println(args); 
        System.out.println(args.length); 
        //System.out.println(args[0]); 
        for(int x=0; x<args.length; x++) {
            System.out.println(args[x]);
        }
    }
}

运行结果：

静态函数

3. 修饰符

java修饰符

4. 关键字

java关键字
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,362评论 5赞 477
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,330评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,247评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,560评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,580评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,569评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,929评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,587评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,840评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,596评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,678评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,366评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,945评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,929评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,165评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 43,271评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,403评论 2赞 342

推荐阅读更多精彩内容

  • Java基础知识总结
    一：java概述：1，JDK：Java Development Kit，java的开发和运行环境，java的开发工...
    ZaneInTheSun阅读 2,627评论 0赞 11
  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,560评论 18赞 399
  • Java基础-面向对象相关（一）
    类与对象 什么是类？ 类是具有相同特征和行为的对象集合。其中特征对应的是成员变量，它存储在堆区中，而行为对应的是方...
    朽木丿碎风阅读 227评论 0赞 0
  • MATLAB面向对象编程模式上
    写在之前 因为简书字数限制，完整版地址：https://www.zybuluo.com/hainingwyx/no...
    hainingwyx阅读 13,860评论 0赞 41
  • 给她一个大大的拥抱
    这几日忙乱得很，本不准备写东西了。可是，有些话语在心里登登地跳着，静不下来。 还是写点吧！ 一位女同事，因为身体原...
    天行健先河阅读 421评论 0赞 0