1 面向对象

我们都知道C语言是面向过程的，C++,Java等语言是面向对象的，那么这两者之间有什么区别呢？来举一个洗衣服的例子：

面向过程：把衣服放在盆中->加入洗衣液->加水->揉洗->换水漂洗->洗好了

面向对象：把衣服和洗衣液放入洗衣机中->洗好了

我们可以看出来，面向过程注重的是过程，而面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来，衣服、洗衣液、洗衣机都可以称为是对象。

2 类与对象

类就是一类对象的统称。

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

所以我们经常会听到一句话：类实例化后就得到了对象，即类是抽象的，对象是具体的。一个类可以生成无数个对象，如果这么说还是有点抽象的话，那我们来举个例子：现在有鞋这么一个类，由这个类我们可以实例化出很多对象，如：运动鞋、休闲鞋、皮鞋等等。

3 类的成员

类的成员有：字段（成员变量）、方法、代码块、内部类和接口等等。

初识面向对象，这里只介绍前面三个。

3.1 字段

字段又可以称为属性、成员变量。我们来看代码：

public class Test {public String name = "ccc";public int age;public static void main(String[] args) {Test test = new Test();test.name = "abc";test.age = 20;System.out.println(test.name);System.out.println(test.age);}
}

输出如下：

abc
20

在Test类下的name、age就被称为属性或成员变量，我们可以在创建的时候给其赋值，也可以在main方法中赋值或修改其值，但是在调用成员变量的时候需要用对象去调用，即用new出来的test对象才能对其进行调用。

注意事项：

• 在成员变量没有赋值之前，会有一个默认值.
• 对于各种数字类型，其默认值为0.
• 对于boolean类型，其默认值为false.
• 对于String等引用类型，默认值为null.

对于null而言：

null在Java中为”空引用“，意思是不指向任何对象，如果对其进行操作，就会出现异常（空指针异常）。

3.2 方法

方法用于描述一个对象的行为，我们来看下面代码：

public class Test {public String name = "张三";public int age = 18;public void show(){System.out.println("我叫" + name + "，我今年" + age + "岁");}public static void main(String[] args) {Test test = new Test();test.show();}
}

输入为：

我叫张三，我今年18岁

其中的show，我们就称为方法，想要调用方法，还是需要创建对象，方法可以满足某种行为，我们还可以根据具体的需要去设置方法的返回类型，传入的参数等等。

3.3 static关键字

1. 修饰成员变量
2. 修饰方法
3. 修饰代码块
4. 修饰类

3.3.1 修饰成员变量

被static修饰的成员变量称为静态成员变量，存放在方法区，又叫静态区，而普通的成员变量是存放在堆区的，局部变量存放在栈区。我们来看看普通的成员变量和静态成员变量有什么区别：

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

输出如下：

1
1
-------------------
1
2

究其原因，普通成员变量是存放在堆区的，在每new一个新的对象时，都会给该对象在堆区开辟一片新的空间用来存放成员变量a，然后未初始化的成员变量值是0，所以test1和test2在调用之前，a的值都为0，调用后都为1，刚刚我们说过static修饰的成员变量是存放在方法区的，静态成员变量是属于类的，我们调用它的时候完全可以不用new对象，并且它在方法区中只有一份，每次调用的都是唯一的那一份，所以后面test2调用b的时候，b的值会变成2。

3.3.2 修饰方法

同上，被static修饰的方法我们就称为静态方法。

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

来看代码：

public class Test {public int a;public static int b;public static void change(){b = 100;//a = 10;  报错，不可以访问非静态成员变量}public static void main(String[] args) {Test.change();System.out.println(b);}
}

输出为：

100

我们可以看出static修饰的方法和普通方法的区别，至于如何去使用，就需要结合具体的情况。

static修饰代码块和类在此处先不作陈述。

4 封装

4.1 private封装

private/ public 这两个关键字表示 “访问权限控制”。我们来看看这两者的区别：

直接使用public

class Person {public String name = "张三";public int age = 18;
}
class Test {public static void main(String[] args) {Person person = new Person();System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");}
}

输入为：

我叫张三, 今年18岁

使用private

class Person { private String name = "张三"; private int age = 18; public void show() { System.out.println("我叫" + name + ", 今年" + age + "岁"); } 
} 
class Test { public static void main(String[] args) { Person person = new Person(); person.show(); } 
}

输入为：

我叫张三, 今年18岁

对于成员变量，其实我们根本不需要知道，也不需要关注一个类都有哪些 private 的成员。从而让类调用者以更低的成本来使用类。并且使用public修饰成员变量其维护成本也会更高，用private进行封装后其可行性更佳。

4.2 getter和setter方法

当我们使用 private 来修饰成员变量的时候, 就无法直接使用这个成员变量了。而我们想要使用它，无非就是想给它赋值或得到其值，在Java中为了解决这个问题，引入了getter和setter方法。

public class Test {private String name;private int age;public void setName(String name){this.name = name;}public String  getName(){return this.name;}public void setAge(int age){this.age = age;}public int getAge(){return this.age;}public static void main(String[] args) {Test test = new Test();test.setName("张三");System.out.println(test.getName());test.setAge(18);System.out.println(test.getAge());}
}

输入为：

张三
18

其中的getName和getAge即为getter方法，表示获取这个成员的值，setName和setAge即为setter方法，表示设置这个成员的值。

注意事项：

• 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this表示当前实例的引用。
• 不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法。

5 构造方法

5.1 基本语法

构造方法是一种特殊方法，在new一个对象的时候会自动调用，用于完成初始化操作。

new执行过程

• 为对象分配内存空间
• 调用对象的构造方法

规则

• 方法名必须与类名相同
• 构造方法没有返回值类型
• 每个类中至少有一个构造方法（如果不定义的话系统会自动生成一个无参构造）
• 若定义了构造方法，则默认的无参构造就没有了
• 构造方法支持重载，和普通方法的重载一样

public class Test {private String name;private int age;public Test(){System.out.println("这是无参构造");}public Test(String name){this.name = name;}public Test(String name,int age){this.name = name;this.age = age;}public static void main(String[] args) {Test test = new Test();Test test1 = new Test("张三");System.out.println(test1.name);System.out.println(test1.age);Test test2 = new Test("张三", 18);System.out.println(test2.name);System.out.println(test2.age);}
}

输出为：

这是无参构造
张三
0
张三
18

从输出可以看出，在new对象时，会根据传入参数的个数自动找到对应的构造方法。

5.2 this关键字

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

public class Test {private String name;private int age;public Test(){this("张三",18);  //this调用构造方法}public Test(String name,int age){this.name = name;this.age = age;}public void show(){System.out.println("我叫" + name + "，今年" + age + "岁");}public static void main(String[] args) {Test test = new Test();test.show();}
}

输入为：

我叫张三，今年18岁

6 代码块

代码块可以分为四种：

• 普通代码块
• 构造代码块
• 静态代码块
• 同步代码块

6.1 普通代码块

定义在方法中的代码块就称为普通代码块。

public class Main{ public static void main(String[] args) { { //直接使用{}定义，普通方法块int x = 10 ; System.out.println("x1 = " +x); } int x = 100 ; System.out.println("x2 = " +x); } 
} 

这种用法无较大意义。

6.2 构造代码块

定义在类中的代码块就称为构造代码块，一般用于初始化成员变量。

public class Test {private String name;private int age;//构造代码块{this.name = "张三";this.age = 18;System.out.println("构造代码块");}public void show(){System.out.println("我叫" + name + "，今年" + age + "岁");}public static void main(String[] args) {Test test = new Test();test.show();}
}

输出为：

构造代码块
我叫张三，今年18岁

6.3 静态代码块

也是在类中定义，一般用于初始化静态成员变量。和构造代码块用法类似，要在{}前面加上static关键字修饰。

注意事项：

• 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
• 静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。