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=red
num=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=red
num=3可见属性的修改并没有预期的效果，因为
new Car().num = 5;
new Car().run();根本就是操作的两个不同的对象，当执行到第二条语句时，第一个对象已经成为垃圾，第二条语句时重新new了一个对象，并且修改了它的一个属性，但是并没有用，因为修改了也不使用，没有指向它的引用。
- 特点：
匿名对象操作其属性没有意义，只能调用其方法。 - 适用场景：
对对象的方法只需要调用一次，可以用匿名对象，这样比较简便，如果需要对多个成员进行调用，必须要有对象引用。
可以将匿名对象作为实际参数传递
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=aaa
num=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;
注意区分。