【手把手带你学JavaSE】第六篇：类和对象

对了！给大家推荐一个刷题学习、面试神器——牛客网




里面有非常多的题库，跟面试经验~非常的良心！！

一、初步认识类和对象

什么是类？
什么是对象？

怎么去理解这两个抽象的概念呢？

1.1 面向对象介绍

Java是一门纯面向对象的语言(Object Oriented Program，继承OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。 用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

1.2 面向对象的理解

举一个非常简单的例子：

以洗衣服为例：拿盆、放水、放衣服、放洗衣粉、手搓、换水、拧干、晾衣服，这个过程就是面向过程。

以洗衣服为例：人把衣服放进洗衣机，倒入洗衣粉，洗完晾干，不需要关心洗衣服整个过程是怎么完成的，只需要找对象，创建对象，使用对象。在好比我们使用toString函数，我们并不关心toString函数具体的实现过程，我们直接交给Arrays帮我们实现就可以了，这就是面向对象。

二、类的定义和使用

2.1 什么是类？类是干嘛的？

定义：类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)。

2.2 怎么使用类？

格式：

// 创建类
class <class_name>{      
	field;//成员属性    
	method;//成员方法
}

// 实例化对象
<class_name> <对象名> = new <class_name>();
1
2
3
4
5
6
7
8

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

练习：定义一个类

class Person{
    //类里面包含字段，也叫做属性，也叫做成员变量
    //也包含方法
    //一个类就是由方法和字段组成的
    public String name;//属性
    public int age;//属性
    //什么是方法？可以解读为这个人的行为
    public void eat(){
        System.out.println(name+" 正在吃饭");
    }
    public void sleep(){
        System.out.println(name+" 正在睡觉");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意事项：

1.一个文件中可以有多个类，但一般一个文件当中只定义一个类
2.main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
3.public修饰的类必须要和文件名相同

2.3 类的实例化

定义:用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

由类Person定义的变量person是引用变量，意味着它的初值可以给null

public class TestDemo {
    public static void main(String[] args) {
        Person person = null;
 
    }
}
1
2
3
4
5
6

实例化对象:

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        //实例化一个对象
    }
}
1
2
3
4
5
6
7

一个类可以实例化多个对象

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();//由类Person实例化了一个对象
        Person person1 = new Person();
        Person person2 = new Person();
        Person person3 = new Person();
        
    }
}
1
2
3
4
5
6
7
8
9

类和对象的说明
1.类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员。
2.类是一种自定义的类型，可以用来定义变量。
3.一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。

三、类的成员

3.1 普通成员变量

字段是定义在类的内部方法的外部，如果定义到方法里头叫做局部变量，定义到方法外头叫做成员变量

如何访问成员变量，成员变量分为两种：(普通成员变量、静态成员变量）。普通的成员变量的访问方式通过引用来访问。

class Person{

    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭");
    }
    public void sleep(){
        System.out.println(name+" 正在睡觉");
    }

}
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

成员变量没有赋初值的情况下都有一个默认的值

如何给成员变量赋值？

class Person{

    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭");
    }
    public void sleep(){
        System.out.println(name+" 正在睡觉");
    }

}
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 10;
        person.name = "zhangsan";
        System.out.println(person.age);
        System.out.println(person.name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

方法也分为两种：一种叫做普通成员方法，一种叫做静态成员方法

普通的成员方法访问方式也是一样的，通过对象的引用来访问我的方法。

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 10;
        person.name = "zhangsan";
        System.out.println(person.age);
        System.out.println(person.name);
        person.eat();
        person.sleep();
    }
}
1
2
3
4
5
6
7
8
9
10
11

3.2 静态成员变量

被static修饰的的变量叫静态成员变量，也叫做类变量，是放在方法区的。

静态成员变量的访问方式是通过类名.静态的成员属性/方法。

不依赖对象

class Person{
 
    public String name;
    public int age;
 
    public static int count;
 
    public void eat(){
        System.out.println(name+" 正在吃饭");
    }
    public void sleep(){
        System.out.println(name+" 正在睡觉");
    }
 
}
 
public class Test {
    public static void main(String[] args) {
        Person.count++;
        System.out.println(Person.count);
        System.out.println("================");
        Person.count++;
        System.out.println(Person.count);
 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

count是被static修饰的静态成员变量，是放在方法区的，不属于某个对象，属于类。正确的访问静态成员变量或者方法只要 类名.静态成员变量/方法 就可以了，所有静态的东西在方法区里只存一份，所以加2遍都是加的count本身，所以第二次打印的结果是2。

普通的方法内部， 不能够定义静态的变量。
1.static定义的变量是类变量，属于类，(定义在方法内部就属于方法了，所以是错误的)

2.eat方法的调用，需要对应的引用来调用。但如果可以定义static的变量，类Person就可以调用，所以两者直接是矛盾的，eat需要对应的引用来调用。size只需要类就可以调用。所以普通的方法内部， 不能够定义静态的变量。

静态的方法也不可以定义静态变量

总结：静态的成员变量是不可以在方法中定义的

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问。
3. 类变量存储在方法区当中。
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)。

【静态方法特性】

1. 不属于某个具体的对象，是类方法。
2. 可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者。
3. 不能在静态方法中访问任何非静态成员变量。

3.3 main函数为什么是静态的？

main函数是不是静态的都可以！
取决于JVM！

四、封装

4.1 概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套上壳屏蔽细节。
比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

什么是封装？

在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度.

4.2 访问限定符

public：公开的，可以理解为一个人的外貌特征，谁都可以看得到

protected：受保护的，涉及到继承中的知识，继承博客中详细介绍

default: 什么都不写时的默认权限，对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：私有的，只有自己知道，其他人都不知道

注意：
protected主要是用在继承中，继承部分详细介绍。
default权限指：什么都不写时的默认权限。
访问权限除了可以限定类中成员的可见性，也可以控制类的可见性。

4.3 private实现封装

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.

直接使用 public

class Person {    
	public String name = "张三";    
	public int age = 18;
}
1
2
3
4

class Test {    
	public static void main(String[] args) {        
		Person person = new Person();        
		System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");    
	}
}
1
2
3
4
5
6

1.这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类. 学习成本较高.
2.一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高.

范例：使用 private 封装属性, 并提供 public 方法供类的调用者使用.

此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.
同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的字段).

注意事项
private 不光能修饰字段, 也能修饰方法。
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.

4.4 getter和setter方法

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了.
此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法.

注意事项
getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置这个成员的值.
当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例的引用.
不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法.
在 IDEA 中可以使用 alt + insert (或者 alt + F12) 快速生成 setter / getter 方法. 在 VSCode 中可以使用鼠标右键菜单 -> 源代码操作 中自动生成 setter / getter 方法.

五、构造方法

5.1 基本语法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.

new 执行过程
1.为对象分配内存空间
2.调用对象的构造方法
语法规则
1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
注意事项
如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
若类中定义了构造方法，则默认的无参构造将不再生成.
构造方法支持重载. 规则和普通方法的重载一致.

5.2 this的引用

定义：this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

结论：

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型 。
2. this只能在"成员方法"中使用。
3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象。
4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法。
5. 对象的引用传递给该成员方法，this负责来接收。

六、代码块

字段的初始化方式有：

1. 就地初始化
2. 使用构造方法初始化
3. 使用代码块初始化

6.1 什么是代码块？

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
本地代码块
构造代码块
静态代码块
同步代码块（后续讲解多线程部分再谈）

6.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);  
	 } 
 }  
1
2
3
4
5
6
7
8
9
10

这种用法较少见

6.3 构造代码块

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

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

6.4 静态代码块

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

注意事项

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