类和对象你了解多少？
目录
- 一、面向对象思想
- 1.1 概述
- 1.2 举例
- 1.3 面向对象设计
- 二、类和对象
- 2.1 类的定义
- 2.2 对象的使用
- 三、类的成员
- 3.1 字段/属性/成员变量
- 3.1.1 成员变量的默认值
- 3.1.2 认识 null
- 3.1.3 字段就地初始化
- 3.2 method方法
- 3.3 static 关键字
- 四、封装
- 4.1 概述
- 4.2 封装的步骤
- 4.3 private实现封装
- 4.4 this关键字
- 4.4.1 含义
- 4.4.2 使用格式
- 注意事项
- 4.5 构造方法
- 4.5.1 构造方法的定义格式
- 4.6 JavaBean
- 五、代码块
- 5.1 什么是代码块
- 5.2 普通代码块
- 5.3 构造代码块
- 5.4 静态代码块
- 六、总结
一、面向对象思想
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 封装的步骤
- 使用private关键字来修饰成员变量。
- 对需要访问的成员变量，提供对应的一对getter方法 、setter方法。
4.3 private实现封装
private的含义：
- private是一个权限修饰符，代表最小权限。
- 可以修饰成员变量和成员方法。
- 被private修饰后的成员变量和成员方法，只在本类中才能访问。
private的使用格式：
private 数据类型 变量名;
- 使用private修饰成员变量，代码如下：
public class Student {
private String name;
private int age;
}
- 提供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 方法能比较稳定，不应该频繁发生大的改变。尤其是对于一些基础库中的类，更是如此。每次接口的变动都要仔细考虑兼容性问题。
看完这一大段是不是还有点懵？？！ 那我们整理一下：为什么要封装？怎么封装？
- 实现封装？用private关键字修饰成员变量。
- private是私有的。被其修饰后，只能在当前类当中使用。
- 每个类都会预留公有的接口。一旦你把这个方法设置为public，那么就不要轻易修改它的属性为其它属性。
- 降低类的调用者对类的使用成本。（会提高开发效率）
- 提供一系列的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(); //静态代码块是否还会被执行？
}
}
注意事项：
- 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
- 静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。
六、总结
- 一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
- 类中定义的属性，大概分为几类：类属性，对象属性。其中被 static 所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
- 静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
- this关键字代表的是当前对象的引用。并不是当前对象。