Java学习苦旅（七）——我有对象啦！！！

引言：对象？什么对象？

想必大家已经知道，我也有对象了。但我这个对象，和一般人认为的对象或许有点差异。

一般人认为的对象：

我眼中的对象：

好了，不开玩笑了。我们直接进入正文。

本篇博客将讲解Java中的类和对象

初识类和对象

在了解类和对象之前，我们先来了解一下面向过程和面向对象。

面向过程和面向对象

面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。

例如洗衣服，如果是面向过程的话，那就得进行下面的步骤：

而 面向对象注重的是对象，也就是参与过程所涉及到的主体，是通过逻辑将一个个功能实现连接起来。 例如同样是洗衣服，如果是面向对象的话， 那就将衣服和洗衣粉放到洗衣机即可，而洗衣机就是一个对象。

C语言是面向过程的 ，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

JAVA是基于面向对象的 ，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

面向对象的概念

1. 面向对象是思考问题的一种思考方式，是一种思想。比如：概念与实例、理论与实践等等。

2. 类就是一类对象的统称。对象就是这一类具体化的一个实例。

3. 面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

面向对象的设计

面向对象设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据（私有）的方法！被动的一方是数据的拥有者，主动的一方是执行者。开发时：找对象，建对象，用对象，并维护对象之间的关系。

类和对象的关系

类就是一类对象的统称。对象就是这一类具体化的一个实例。

简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象，所以月饼就是一个实体。一个模子可以实例化无数个对象。

总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

因此， 面向对象就是用代码(类)来描述客观世界的事物的一种方式，一个类主要包含一个事物的属性和行为。

类和类的实例化

类

类的基本语法

// 创建类
class <class_name>{  
    field;//成员变量
    method;//成员方法
}

class为定义类的关键字，className为类的名字，{}中为类的主体。成员变量是定义在类中、方法外的变量。成员方法是定义在类中的方法。

代码示例

例如：

class Person {
    //成员变量
    public int age;
    public String name;
    public String sex;
    
    //成员方法
    public void eat() {
        System.out.println("吃饭");
    }
}

类的实例化

用类类型创建对象的过程，称为类的实例化

new 关键字用于创建一个对象的实例 ，例如：

class Person {
    public int age;
    public String name;
    public String sex;
    public void eat() {
        System.out.println("吃饭");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        
        //类型  引用变量 = 对象
        Person person = new Person();//实例化一个对象
    }
}

一个类可以实例化多个对象 ，例如：

Person person1 = new Person();
Person person2 = new Person();
Person person3 = new Person();

使用 . 来访问对象中的属性和方法 ，例如：

person1.age = 10;
person2.eat();

类的成员

字段/属性/成员变量

在类中，但在方法外部定义的变量，这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”。 这个变量的作用是用于描述一个类中包含哪些数据。

我们可以看看下面这段代码：

class Person {
    public int age;
    public String name;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.age);
        System.out.println(person.name);
    }
}

这段代码的执行结果为：

age和name并未赋初值。因此， 对于一个对象的字段如果没有显式设置初始值，那么会被设置一个默认的初值。

默认值规则

对于基本类型，默认值为 0。

对于char类型，默认值为 ‘\u0000’。

对于 boolean 类型，默认值为 false。

对于引用类型(String，Array，以及自定制类)，默认值为null。

null 在 Java 中为 “空引用”，表示不引用任何对象，类似于 C 语言中的空指针。

成员方法

成员方法是定义在类中的方法，用于描述一个对象的行为。

例如：

class Person {
    public int age;
    public String name;
    public void show() {
        System.out.println("姓名：" + name + " 年龄： " + age);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 3;
        person.name = "rampant boy";
        person.show();
    }
}

结果为：

static关键字

修饰变量

static修饰的成员变量被称为静态成员变量，也叫类变量。 静态成员变量存储在方法区。 访问方式为：类名.成员变量。

例如：

class Person {
    public int age;
    public static int count;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(Person.count);
    }
}

结果为：

Java静态成员变量和类相关，和具体的实例无关。换句话说，同一个类的不同实例共用同一个静态成员变量。 例如：

class Test {
    public int a;
    public static int count;
}

public class TestDemo {
    public static void main(String[] args) {
        Test test1 = new Test();
        test1.a++;
        Test.count++;
        System.out.println("a = " + test1.a);
        System.out.println("count = " + Test.count);
        System.out.println("=============");
        Test test2 = new Test();
        test2.a++;
        Test.count++;
        System.out.println("a = " + test2.a);
        System.out.println("count = " + Test.count);
    }
}

结果为：

原因是：

静态的成员变量在方法区只存在一个。 因此count等于2。

修饰方法

在任何方法上应用static关键字，此方法称为静态方法。

静态方法属于类，而不属于类的对象。可以直接调用静态方法，而无需创建类的实例。静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

例如：

class Person {
    public int age;
    public static int count;
    public static void changeCount() {
        count = 10;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("改变前：" + Person.count);
        Person.changeCount();
        System.out.println("改变后：" + Person.count);
    }
}

结果为：

注：静态方法中不能调用普通方法，而普通方法中可以调用静态方法。因为普通方法的调用需要依赖于对象，而静态方法不依赖于对象。

封装

什么是封装

《代码大全》开篇就在讨论一个问题：软件开发的本质就是对程序复杂程度的管理。如果一个软件代码复杂程度太高，那么就无法继续维护。如何管理复杂程度？封装就是最基本的方法。

在我们写代码的时候经常会涉及两种角色： 类的实现者和类的调用者 。

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的，只要知道如何使用类就行了.

这样就降低了类使用者的学习和使用成本，从而降低了复杂程度。

private实现封装

private和public这两个关键字表示 “访问权限控制” 。

• 被public修饰的成员变量或者成员方法，可以直接被类的调用者使用。

• 被private修饰的成员变量或者成员方法，不能被类的调用者使用。

例如：

class Test {
    private String name;
    public void setName(String myName) {
        this.name = myName;
    }
    public String getName() {
        return name;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Test test = new Test();
        test.setName("张三");
        System.out.println(test.getName());
    }
}

结果为：

多个封装的成员变量需要调用

当有多个成员变量被封装时，如果我们想调用，一个一个设置的话，就比较麻烦。这时，我们就可以使用快捷键：alt+Insert（或者鼠标右键，然后点击Generate），然后选择Getter and Setter，然后按住shift键，点击所需要设置的变量，再点击ok即可。

构造方法

构造方法是一种特殊方法，使用关键字new实例化新对象时会被自动调用，用于完成初始化操作。

语法规则

1. 方法名称必须与类名称相同

2. 构造方法没有返回值类型声明

3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项

1. 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数。

2. 若类中定义了构造方法，则默认的无参构造将不再生成。

3. 构造方法支持重载，规则和普通方法的重载一致。

代码示例

class Test {
    public String name;
    public Test() {
        System.out.println("不带参数的构造方法");
    }
    public Test(String name) {
        this.name = name;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test("张三");
        System.out.println(test2.name);
    }
}

结果为：

this关键字

细心的读者会发现，在前面的代码中出现了this这个关键字，那这个关键字有什么作用呢？

this表示当前对象引用， 可以借助 this 来访问对象的成员变量和方法。

• this.成员变量：调用成员变量

• this.成员方法：调用成员方法

• this()：调用其他构造方法

注：this调用构造方法时，一定要写在第一行。同时不能在静态方法当中调用this

代码块

代码块是使用 {} 定义的一段代码

本地代码块

本地代码块：定义在方法中的代码块。

例如：

public class TestDemo {
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println("a = " + a);
        }
        int a = 20;
        System.out.println("a = " + a);
    }
}

结果为：

构造代码块

构造代码块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

例如：

class Test {
    public int age;
    public int tele;
    {
        this.age = 10;
        this.tele = 12345678;
    }//实例代码块
}

静态代码块

静态代码块：使用static定义的代码块。一般用于初始化静态成员变量和需要提前准备的一些数据。

例如：

class Test {
    public static int age;
    public int tele;
    static {
        age = 100;
    }//静态代码块
}

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

匿名对象

匿名对象是没有引用的对象。 匿名对象只能在创建对象时使用.如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象。例如：

class Person {
    public int age;
    public String name;
    public void eat() {
        System.out.println("吃饭");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        new Person().eat();//new.Person()就是匿名对象。
    }
}

结果为：

本篇博客到此结束。

上一篇博客：Java学习苦旅（六）——不一样的数组

下一篇博客预告：Java学习苦旅（八）——不复杂的复杂度