Java重修之路（六）面向对象初识，类与对象，成员变量，局部变量，封装，构造函数，构造代码块，this关键字

今天终于进入正题，Java的面向对象部分，也是Java的核心部分，如果之前只是学过C语言而没有接触其他面向对象的语言的同学，这里要转换思想还是有些难度的，需要多思考，弄清楚什么是面向对象，面向对象与面向过程的区别。不多说废话，开始了。

- 面向对象概述

面向过程是功能行为，就是将功能封装给对象，强调了具备有功能的对象，对象具有一定的特征和功能，在使用的时候只需要找到相应的对象，就能获得其特征和功能。

类与对象的关系

类是对对象的描述，包括对象的特征，功能。
对象是一个个实体。

- 成员变量与局部变量

成员变量作用于整个类中，局部变量作用于函数中或者语句中。
在内存中成员变量在堆内存中，因为对象的存在才在内存中存在，而局部变量存在于栈内存中。

匿名对象

没有变量名的对象。即没有指向它的引用

public class Hello {    public static void main(String[] args) {//      new Car().run();        Car c=new Car();        c.run();    }    public static class Car{        String color="red";        int num=3;        public void run(){            System.out.println("color="+color+"\nnum="+num);        }    }}

这两种写法效果是一样的，但是接下来往下看：

public class Hello {    public static void main(String[] args) {//      new Car().run();        Car c=new Car();        c.num=5;        c.run();    }    public static class Car{        String color="red";        int num=3;        public void run(){            System.out.println("color="+color+"\nnum="+num);        }    }}输出结果为：color=rednum=5

但是对于匿名对象来说，修改属性是没有意义的：

public class Hello {    public static void main(String[] args) {        new Car().num = 5;        new Car().run();    }    public static class Car {        String color = "red";        int num = 3;        public void run() {            System.out.println("color=" + color + "\nnum=" + num);        }    }}输出结果为：color=rednum=3

可见属性的修改并没有预期的效果，因为

new Car().num = 5;new Car().run();

根本就是操作的两个不同的对象，当执行到第二条语句时，第一个对象已经成为垃圾，第二条语句时重新new了一个对象，并且修改了它的一个属性，但是并没有用，因为修改了也不使用，没有指向它的引用。

1. 特点：
   匿名对象操作其属性没有意义，只能调用其方法。
2. 适用场景：
   对对象的方法只需要调用一次，可以用匿名对象，这样比较简便，如果需要对多个成员进行调用，必须要有对象引用。
   可以将匿名对象作为实际参数传递

public class Hello {    public static void main(String[] args) {        // Car c=new Car();        // changeCar(c);        changeCar(new Car());    }    public static class Car {        String color = "red";        int num = 3;        public void run() {            System.out.println("color=" + color + "\nnum=" + num);        }    }    public static void changeCar(Car c) {        c.num = 100;        c.color = "aaa";        c.run();    }}输出结果：color=aaanum=100

两种情况的内存图

两者还有一点区别就是：匿名对象作为实际参数传递，当函数调用完成，生命周期结束，匿名对象又沦为垃圾，而第一种不会。

- 封装

Java三大特性之一

public static void show(int x) {    check(x);}private static void check(int x) {    if (x <= 0) {        System.out.println("数据不合法！");    } else {        System.out.println(x);    }}在一个类中有这两个方法，只需要将show方法暴露出去给人使用，而check方法时内部检查使用，不需要暴露出去，所以用private修饰。

封装不是私有，私有仅仅是封装的一种表现形式。

public class Person {    private int age;    private String name;    public int getAge() {        return age;    }    public void setAge(int age) {        if (age < 0 || age > 200) {            System.out.println("年龄不合法！");            return;        }        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}这里将age,int的权限设为private，所以不能通过对象.属性来设置值，因为外边访问不到，然后对外提供setAge方法，只能通过此方法设置值。

- 构造函数

对象一建立就会调用与之对应的构造函数。

public class Hello {    public static void main(String[] args) {        new Demo();    }    public static class Demo {        Demo() {            System.out.println("这是构造函数！");        }    }}输出结果：这是构造函数！

由于构造函数的特性，可以在构造函数里面进行初始化。
多个构造函数之间是重载的形式出现的。

构造函数的重载public Person() {    }    public Person(int age) {    }    public Person(int age, String name) {    }    public Person(String name, int age) {    }

每一个类都有一个默认的空参数的构造函数，但是一旦你自己写了构造函数，则默认的构造函数就不存在了。
构造函数和一般方法的区别：
构造函数在对象一建立就执行，一般方法是需要对象主动调用才执行。
一个对象建立，构造函数只执行一次，一般方法可以被对象调用多次。
构造函数适用情景：
对象本身具有的一些特征，在构造函数里面初始化。

- 构造代码块

给对象化初始化，对象一建立就执行，而且优先于构造函数执行。
和构造函数的区别：
构造代码块是给所有的对象统一初始化，而构造函数是给对应的的对象初始化。
适用情景：对象的公共属性在构造代码块里面统一初始化。

- this关键字

首先下边的场景：

import javax.print.DocFlavor.STRING;public class Person {    private String name;    public String getName() {        return name;    }    public void setName(String name) {        name = name;    }}这里给name赋值的时候，左边的name指的是本类中的成员变量，右边的name指的是传经来的参数，但是如果按这种写法，name并没有成功赋值：

Person person = new Person();person.setName("zhangsan");System.out.println(person.getName());输出结果是：null

所以必须要有一个关键字，告诉程序将传进来的值赋给本类的成员变量，所以用到关键字this，this代表的是本类。

public void setName(String name) {        this.name = name;    }

就能成功赋值。

- this关键字在构造函数之间的调用

public class Person {    private int age;    private String name;    public Person(String name) {        this.name = name;    }    public Person(int age, String name) {        // this.name = name;        this(name);        this.age = age;    }}有两个构造函数，但是设置姓名的构造函数在前边已经有了，此时就可以用this来调用，但是注意：this(name);必须放在最前面，不能放在this.age = age;后边至于为什么，看下边的代码：

import javax.print.DocFlavor.STRING;public class Person {    private int age;    private String name;    public Person(String name) {        this.name = "abcd";    }    public Person(int age, String name) {        // this.name = name;        this(name);        this.age = age;    }}

假设是：
this.name = name;//此时name=传进来的参数
this(name);//name=“abcd” 覆盖掉了
下边这种 情况：
this(name);//

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

this.name = name;
注意区分。