类和对象你了解多少？

---

一、面向对象思想

1.1 概述

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下， 使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

---

1.2 举例

洗衣服：

• 面向过程： 把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
• 面向对象： 把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来

区别：

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

• 面向过程： 强调步骤，注重的是过程，在整个过程中所涉及的行为，就是功能。
• 面向对象： 强调对象，这里的对象就是洗衣机，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。

---

1.3 面向对象设计

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

特点
面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。 面向对象的语言中，包含了几种基本特征，即封装、继承、多态和组合。

---

二、类和对象

什么是类

• 类： 是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物：

• 属性： 就是该事物的状态信息。
• 行为： 就是该事物能够做什么。

什么是对象

• 对象： 是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。

类与对象的关系

• 类是对一类事物的描述，是抽象的。
• 对象是一类事物的实例，是具体的。
• 类是对象的模板，对象是类的实体。

---

2.1 类的定义

声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类。

基本语法

// 创建类
class <class_name>{  
    field;//成员属性
    method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
类中的元素称为：成员属性。
类中的函数称为：成员方法。

代码示例：

class Person {
	public int age;			//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {		//成员方法
    	System.out.println("吃饭!");  
    }
    public void sleep() {
    	System.out.println("睡觉!");  
	}
}

---

2.2 对象的使用

对象的使用格式
创建对象：

类名 对象名 = new 类名();

使用对象访问类中的成员：

对象名.成员变量;
对象名.成员方法();

代码示例：

class Person {
    public int age;		//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {		//成员方法
    	System.out.println("吃饭!");  
	}
    public void sleep() {
    	System.out.println("睡觉!");  
	}
}
public class Main{
	public static void main(String[] args) {
    	Person person = new Person();	//通过new实例化对象
        person.eat();	//成员方法调用需要通过对象的引用调用
        person.sleep();
        //产生对象     实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
	}
}

注意事项

• new 关键字用于创建一个对象的实例。
• 使用 . 来访问对象中的属性和方法。
• 同一个类可以创建多个实例。

---

三、类的成员

3.1 字段/属性/成员变量

在类中，但是方法外部定义的变量。这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”(三种称呼都可以，一般不会严格区分)。
用于描述一个类包含哪些数据。

class Person {
	public String name;   // 字段
    public int age; 
}
class Test {
	public static void main(String[] args) {
    	Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
	}
}
// 执行结果
null
0

注意事项

• 使用 . 访问对象的字段。
• “访问” 既包含读, 也包含写。
• 对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值。

3.1.1 成员变量的默认值

3.1.2 认识 null

null 在 Java 中为 “空引用”，表示不引用任何对象。类似于 C 语言中的空指针。如果对 null 进行 . 操作就会引发异常。

代码示例：

class Person {
    public String name;
    public int age;
}
class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name.length());   // 获取字符串长度
   }
}
// 执行结果
Exception in thread "main" java.lang.NullPointerException
        at Test.main(Test.java:9)

3.1.3 字段就地初始化

很多时候我们不希望字段使用默认值，而是需要我们显式设定初值。

代码示例：

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);
        System.out.println(person.age);
   }
}
// 执行结果
张三
18

---

3.2 method方法

用于描述一个对象的行为。

代码示例：

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

此处的 show 方法，表示 Person 这个对象具有一个 “展示自我” 的行为。
这样的 show 方法是和 person 实例相关联的。如果创建了其他实例，那么 show 的行为就会发生变化。

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person2.show()
    
// 执行结果
我叫李四, 今年20岁

方法中还有一种特殊的方法称为 构造方法 (construction method)。
在实例化对象的时候会被自动调用到的方法，方法名字和类名相同，用于对象的初始化。
虽然我们前面已经能将属性就地初始化，但是有些时候可能需要进行一些更复杂的初始化逻辑，那么就可以使用构造方法。

---

3.3 static 关键字

修饰属性： Java静态属性和类相关，和具体的实例无关。换句话说，同一个类的不同实例共用同一个静态属性。

修饰方法： 如果在任何方法上应用 static 关键字，此方法称为静态方法。

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

注意事项1：
静态方法和实例无关，而是和类相关。因此这导致了两个情况：

• 静态方法不能直接使用非静态数据成员或调用非静态方法（非静态数据成员和方法都是和实例相关的）。
• this和super两个关键字不能在静态上下文中使用（this 是当前实例的引用，super是当前实例父类实例的引用，也是和当前实例相关）。

注意事项2：

• 我们曾经写的方法为了简单，都统一加上了 static。但实际上一个方法具体要不要带 static，都需要是情形而定。
• main方法为 static 方法。

---

四、封装

4.1 概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则： 将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

---

4.2 封装的步骤

1. 使用private关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对getter方法 、setter方法。

---

4.3 private实现封装

private的含义：

1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式：

private 数据类型 变量名;

1. 使用private修饰成员变量，代码如下：

public class Student { 
	private String name; 
	private int age; 
}

2. 提供getter方法 / setter方法，可以访问成员变量。

代码示例：

class Person { 
	private String name;	//实例成员变量
	private int age; 
 
	public void setName(String name) { 
		//name = name;	//不能这样写
		this.name = name;	//this引用，表示调用该方法的对象
	} 
	public String getName() { 
		return name; 
	} 
 
	public void show() { 
		System.out.println("name: "+name+" age: "+age); 
	} 
} 
public static void main(String[] args) { 
	Person person = new Person(); 
	person.setName("caocao"); 
	String name = person.getName(); 
	System.out.println(name); 
	person.show(); 
} 
// 运行结果
caocao 
name: caocao age:0

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

那么再聊聊一个问题：类的实现者万一修改了 public 方法 show 的名字，岂不是类的调用者仍然需要大量修改代码吗?
这件事情确实如此，但是一般很少会发生。一般类的设计都要求类提供的 public 方法能比较稳定，不应该频繁发生大的改变。尤其是对于一些基础库中的类，更是如此。每次接口的变动都要仔细考虑兼容性问题。

看完这一大段是不是还有点懵？？！ 那我们整理一下：为什么要封装？怎么封装？

1. 实现封装？用private关键字修饰成员变量。
2. private是私有的。被其修饰后，只能在当前类当中使用。
3. 每个类都会预留公有的接口。一旦你把这个方法设置为public，那么就不要轻易修改它的属性为其它属性。
4. 降低类的调用者对类的使用成本。（会提高开发效率）
5. 提供一系列的getter和setter方法。

---

4.4 this关键字

我们发现setter方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？

代码示例：

public class Student { 
	private String name; 
	private int age; 
	public void setName(String name) { 
		name = name; 
	}
	public void setAge(int age) { 
		age = age; 
	} 
}

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了 setter() 的形参变量名后，方法并没有给成员变量赋值！ 这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无 法访问到成员变量，从而赋值失败。 所以，我们只能使用this关键字，来解决这个重名问题。

4.4.1 含义

this代表所在类的当前对象的引用（地址值），即对象自己的引用。
总之记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

4.4.2 使用格式

this.成员变量名;

使用this修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：

public class Student { 
	private String name; 
	private int age; 
	public void setName(String name) { 
		//name = name; 
		this.name = name; 
	}
	public String getName() { 
		return name; 
	}
	public void setAge(int age) { 
		//age = age; 
		this.age = age; 
	}
	public int getAge() { 
		return age;
	}
}

注意事项

---

4.5 构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

注意：无论你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法， 一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

4.5.1 构造方法的定义格式

修饰符 构造方法名(参数列表){ 
	// 方法体
}

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。
使用构造方法后，代码如下：

public class Student { 
	private String name; 
	private int age; 
	// 无参数构造方法 
	public Student() {} 
	// 有参数构造方法 
	public Student(String name,int age) { 
		this.name = name; 
		this.age = age; 
	} 
}

注意事项：

• 如果你不提供构造方法，系统会给出无参数构造方法。
• 如果你提供了构造方法，系统将不再提供无参数构造方法。
• 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

---

4.6 JavaBean

JavaBean是 Java语言编写类的一种标准规范。符合JavaBean的类，要求类必须是具体的和公共的，并且具有无 参数的构造方法，提供用来操作成员变量的set和get方法。

public class ClassName{ 
	//成员变量 
	//构造方法 
	//无参构造方法【必须】 
	//有参构造方法【建议】 
	//成员方法 
	//getter() 
	//setter() 
}

编写符合 JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student { 
	//成员变量 
	private String name; 
	private int age; 
	//构造方法 
	public Student() {} 
	
	public Student(String name,int age) { 
		this.name = name; 
		this.age = age; 
	}
	//成员方法 
	publicvoid setName(String name) { 
		this.name = name; 
	}
	public String getName() { 
		return name; 
	}
	publicvoid setAge(int age) { 
		this.age = age; 
	}
	publicint getAge() { 
		return age; 
	} 
}

测试类，代码如下：

public class TestStudent { 
	public static void main(String[] args) { 
		//无参构造使用 
		Student s= new Student(); 
		s.setName("胖胖"); 
		s.setAge(18); 
		System.out.println(s.getName()+"‐‐‐"+s.getAge());
		//带参构造使用 
		Student s2= new Student("黄黄",18); 
		System.out.println(s2.getName()+"‐‐‐"+s2.getAge()); 
	} 
}

---

五、代码块

5.1 什么是代码块

使用 {} 定义的一段代码。

根据代码块定义的位置以及关键字，又可分为以下四种：

• 普通代码块
• 构造块
• 静态块
• 同步代码块（后续讲解多线程部分再谈）

---

5.2 普通代码块

普通代码块：定义在方法中的代码块.

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); 
	} 
} 
// 执行结果
x1 = 10 
x2 = 100

这种用法较少见。

---

5.3 构造代码块

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

class Person{ 
	private String name;//实例成员变量
	private int age; 
	private String sex; 
 
	public Person() { 
		System.out.println("I am Person init()!"); 
	} 
 
	//实例代码块
	{ 
		this.name = "bit"; 
		this.age = 12; 
		this.sex = "man"; 
		System.out.println("I am instance init()!"); 
	} 
 
	public void show(){ 
		System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
	} 
} 
public class Main { 
	public static void main(String[] args) { 
		Person p1 = new Person(); 
		p1.show(); 
	} 
} 
// 运行结果
I am instance init()! 
I am Person init()! 
name: bit age: 12 sex: man 

注意事项： 实例代码块优先于构造函数执行。

---

5.4 静态代码块

使用static定义的代码块。一般用于初始化静态成员属性。

class Person{
	private String name;	//实例成员变量
	private int age; 
	private String sex; 
	private static int count = 0;	//静态成员变量 由类共享数据 方法区
 
	public Person() { 
		System.out.println("I am Person init()!"); 
} 
 
//实例代码块
	{ 
		this.name = "bit"; 
		this.age = 12; 
		this.sex = "man"; 
		System.out.println("I am instance init()!"); 
	} 
 
//静态代码块
	static { 
		count = 10;	//只能访问静态数据成员 
		System.out.println("I am static init()!"); 
	} 
 
	public void show() { 
		System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
	}  
} 
public class Main { 
	public static void main(String[] args) { 
		Person p1 = new Person(); 
		Person p2 = new Person();	//静态代码块是否还会被执行？
	} 
}

注意事项：

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

---

六、总结

1. 一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
2. 类中定义的属性，大概分为几类：类属性，对象属性。其中被 static 所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
3. 静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
4. this关键字代表的是当前对象的引用。并不是当前对象。

---