类和对象（面向对象的初步认知）

面向对象的初步认知

什么是面向对象

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

面向对象与面向过程

传统面向过程编程细节非常多，用户使用起来成本非常高，扩展或者维护使用都是非常繁琐的。
面向过程整体执行流程中对象的概念非常弱化，关心的是方法之间的具体调用，至于谁在调用方法，方法操作的是什么并不关心。
而面向对象编程，在整个过程中，关心的是哪个对象，做什么等等，具体怎么做的流程细节并不关心。
例如洗衣服：
总共有四个对象:人，衣服、洗衣粉、洗衣机。
整个洗衣服的过程:入将衣服放进洗衣机、倒入洗衣粉，启动洗衣机，洗衣机就会完成洗衣过程并且甩干。
整个过程主要是:人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关新洗衣机具体是如何洗衣服的，是如何甩干的。

类

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。
比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。
属性：产品品牌，型号，产品重量，外观尺寸，颜色…
功能：洗衣，烘干、定时…

类定义和使用

在java中定义类时需要用到class关键字，具体语法如下

// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
//class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

一个源文件只能存在一个主类（主类名必须和源文件相同）
class声明的普通类可以存在多个
类只是一个模板，没有具体的意义
该类所有的对象都具备定义在类中成员属性和成员方法
不同对象的属性值和具体表现出来的行为都是不同的

类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog类和Student类。它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。
用类 类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public class Main{
	public static void main(String[] args) {
		PetDog dogh = new PetDog(); //通过new实例化对象
		dogh.name = "阿黄";
		dogh.color = "黄";
		dogh.barks();
		dogh.wag();
	}
}

class PetDog {
	public String name = "阿黄";//名字
	public String color = "黄";//颜色
	// 狗的属性
	public void barks() {
		System.out.println(name + ": 旺旺旺~~~");
	}
		// 狗的行为
	public void wag() {
		System.out.println(name + ": 摇尾巴~~~");
	}
}

Java中使用 “.”来访问对象中的属性和方法。
同一个类可以创建多个实例。

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员。
2. 类是一种自定义的类型，可以用来定义变量。
3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
4. 打个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

对象的构造及初始化

就地初始化

在声明成员变量时，就直接给出了初始值。

public class Date {
	public int year = 1900;
	public int month = 1;
	public int day = 1;
	public Date(){
	}
	public Date(int year, int month, int day) {
	}
	public static void main(String[] args) {
		Date d1 = new Date(2021,6,9);
		Date d2 = new Date();
	}
}

代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

构造方法

1. 名字必须与类名相同
2. 没有返回值类型声明，设置为void也不行（如：void Dog（）就不是构造方法）
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
5. 若在定义类时，没有明确定义构造方法，那么编译器编译时会自动生成默认的无参构造；若在类中定义了构造方法，那么默认的无参构造就不再生成。

构造方法实在产生对象时编译器自动调用，为对象的初始化服务。
如：Dog dog = new Dog（）；
这个代码运行时会先检测Dog这个类是否被加载到JVM中，如果没有就加载，然后执行下一步；
执行关键字new，new会在堆上开辟一块空间，开辟多大的内存看这个类中成员属性的类型和个数来决定（内存寻址是JVM来运行的，对程序员和用户不可见，引用数据类型的大小也是由JVM动态计算的，对程序员不可见）；
调用构造方法为每个成员属性赋值（构造方法就是在产生对象时给属性赋值的），类中的变量都有默认值，默认值就是其数据类型的默认值（无参构造都是默认值，一个都不赋值，有参构造就根据参数的个数来决定赋值哪几个成员变量）。
在IDEA中通过 ALT+Insert 来快捷生成构造方法，要初始化哪个或者哪些可以按住ctrl多选 ctrl + A 全选

this关键字

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
this修饰成员变量：

public class Date {
	public int year;
	public int month;
	public int day;
	public void setDay(int year, int month, int day){
		this.year = year; //此处如果写 year = year会赋值失败 
		this.month = month; // 相当于形参自己给自己赋值
		this.day = day;
	}
	public void printDate(){
		System.out.println(this.year + "/" + this.month + "/" + this.day);
	}
}

this修饰成员方法，表示调用类中成员方法 语法： this.方法名称

public void test(){
	this.fun();
}
public void fun(){
	System.out.println(this.name + this.age);
}

this调用构造方法 （构造方法之间才能相互调用且不能成环）语法：this（参数）
构造方法中，可以通过this调用其他构造方法来简化代码
如：车辆的初始化
发动机初始化 构造方法1
变速箱初始化 构造方法2
整体车辆初始化 可以直接通过this调用构造方法1和2 （一个构造方法内部只能调用一次另一个构造方法）

public class Date {
	public int year;
	public int month;
	public int day;
	// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
	// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
	// 但是this(1900,1,1);必须是构造方法中第一条语句
	public Date(){
		//System.out.println(year); 注释取消掉，编译会失败
		this(1900, 1, 1);
		//this.year = 1900;
		//this.month = 1;
		//this.day = 1;
	}
	// 带有三个参数的构造方法
	public Date(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
}

this(…)必须是构造方法中第一条语句，且不能形成环

public Date(){
	this(1900,1,1);
}
public Date(int year, int month, int day) {
	this();
}
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

this还可以表示当前对象的引用

static关键字及用法

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共
享的。
【静态成员变量特性】
不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
类变量存储在方法区当中
生命周期伴随类的一生

1.static修饰属性，称之为类属性，静态属性 放在JVM的方法区
要在类中定义类属性，必须使用static关键字 ，此时没有对象也能用
静态属性通过类名直接调用

Java不支持在方法中定义静态变量，在方法中定义的都是局部变量，存储在栈帧中

静态变量可以被修改

此时同样不会报错，相当于直接通过类调用

2.static修饰方法 类方法，直接通过类名称调用，与对象无关
一个类的工具方法一般设计为静态方法，与具体的对象无关 如：

Math.max(a,b)   //通过Math类直接调用
Arrays.copyOf();Arrays.toString();Arrays.sort();

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

3.static修饰的静态域和成员域之间的关系
静态方法不能调用成员方法或成员变量（只能通过对象调用）
成员方法中可以调用静态属性和静态方法(不推荐)

4.static变量的初始化
构造方法一般初始化的都是成员属性，构造方法是产生对象时为对象初始化的
静态变量一般就地初始化或者在静态代码块中初始化。

5.static 无法直接修饰外部类（Java中直接定义的类）
可以修饰内部类（一个类嵌套在另一个类内部）

代码块

代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块

普通代码块

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

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

构造代码块

直接在类中定义，使用{}的代码块称之为构造代码块。也叫：实例代码块。
在编译之后，会将多个构造块中所有代码按照顺序编译到构造方法的源代码之前，统一合并到构造方法中去

public class Student{
	//实例成员变量
	private String name;
	private String gender;
	private int age;
	private double score;
	public Student() {
		System.out.println("I am Student 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) {
		Student stu = new Student();
		stu.show();
	}
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man

构造块按照书写顺序从上到下执行，同时构造块优先于构造方法执行

静态代码块

使用static修饰，直接定义在类中的代码块成为静态代码块，一般用于初始化静态成员变量。
静态代码块在类的加载时执行一次，和具体产生对象无关 肉有多个静态块，按照书写顺序执行。

主类中的静态代码块会优先于主方法执行

静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
构造代码块只有在创建对象时才会执行

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
	class InnerClass{
	}
}
// OutClass是外部类
// InnerClass是内部类 可以被static修饰

内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

内部类的分类

内部类都可以在一个类的哪些位置进行定义

public class OutClass {
	// 成员位置定义：未被static修饰 --->实例内部类
	public class InnerClass1{
	}
	// 成员位置定义：被static修饰 ---> 静态内部类
	static class InnerClass2{
	}
	public void method(){
	// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
		class InnerClass5{
		}
	}
}

1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
2. 局部内部类(不谈修饰符)、匿名内部类