07、面向对象——类

面向过程的语言：C

世界的一切会认识是相关联的，具有因果关系
一个个的具有因果关系的小系统组成大系统
一个个的具有因果关系的大系统组成超大系统

面对对象的语言：Java

基于面向过程的语言
世界一个一个孤立的事物，相互无因果关系，在外部驱动下对象之间相互传递信息

面向过程的语言和面向过程的语言的区别

面向过程：强调的是每一个功能的步骤
面向对象：强调的是每一个对象，然后由对象去调用功能

面向对象的思想

1、面向对象就是一种常见的思想，符合人们的思考习惯
2、面向对象的出现，将复杂的问题简单化
3、面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者

使用 Java 语言对现实生活中的事物进行描述，通过类的形式来体现的
面向对象强调的是对象实例、强调的是动作，对象将动作进行封装
在问题领域中，我们先去找的都是涉及的对象，然后分析对象的属性和行为

面向对象的开发、设计、特征

面向对象开发：不断的创建对象，使用对象，指挥对象做事情
面向对象设计：管理和维护对象之间的关系
面向对象的特征：封装性、继承性、多态性

描述

Java 就是描述现实的事物
Java 中最基本的单位是：类
所以应该把事物通过类来体现出来
由此，得到了现实世界事物和类的对应关系

对于事物描述通常只关注两方面
一个是属性，一个是行为
只要明确该事物的属性和行为并定义在类中即可

类与对象之间的关系

类：就是对事物的描述，其实类就是将对象共性的内容进行抽取
对象：就是该类事物实实在在存在个体，在 Java 中通过 new 来完成创建的，堆内存的对象主要用于封装对象中的特有数据
定义类其实就是在定义类中的成员
成员：成员变量<–>属性，成员方法<–>行为

成员变量和局部变量的区别

1、
成员变量：类中方法外
局部变量：在方法内，方法定义时的形参也是（数据类型是基本数据类型），在()，{}中定义的也是

2、
成员变量存在于堆内存的对象中
局部变量存在于栈内存的方法中

3、
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

4、
成员变量都有默认初始化值
局部变量没有默认初始化值，参与运算前一定要赋值（初始化）

创建实例

在计算机中创建一个 car 的实例，通过 new 关键字

Car c = new Car();// c就是一个类类型的引用变量，指向了该类的对象
c.run();//要使用对象中的内容可以通过  对象.成员 的形式来完成调用
public static void show(Car c)//类类型的变量一定指向对象。要不就是null 
{
	c.num = 3;
	c.color = "black";
	System.out.println(c.num+"..."+c.color);
}

匿名对象

没有名字的对象

new Car();//匿名对象，其实就是定义对象的简写格式

应用场景：
调用方法，仅仅调用一次的时候
可以作为实际参数传递

封装

隐藏实现细节，并对外提供公共的访问方式
函数或者类都是一个封装体

好处：
1、隔离的变量
2、隐藏实现细节
3、便于使用
4、提高复用
5、提高安全性

设计原则：
把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
private 是封装的一种体现

体现之一：私有，私有在源代码中的使用就是在本类中有效
通常会将成员变量 xxx 私有化，并对外提供对应的 setxxx() getxxx() 方法对其进行访问
其实目的就是成员变量访问进行控制。让成员的访问具备可控性，提高了程序的健壮性
私有仅仅是封装的体现形式之一而已

构造函数

构建创造对象时调用的函数
作用：可以给对象进行初始化，创建对象都必须要通过构造函数初始化

写法特点：
1、方法名和类名相同
2、没有返回值类型，连 void 都不能有
3、没有返回值

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数
如果在类中定义了指定的构造函数，那么类中的默认构造函数就会消失

构造方法的注意点：
1、如果我们没写构造方法，Java 提供一个默认的无参构造方法
2、如果我们写了构造方法（可以是无参可以是有参）， Java 将不再提供默认的无参构造方法
3、想要一个无参构造方法，再写一个无参构造方法
构造方法可以带有 return 语句，不出错，写不写都无所谓，建议不写

给成员变量赋值的方式：
1、setXXX()
2、对象名.成员变量
3、带参构造方法

细节：
1、构造函数如果完成了 set 功能，set 方法是否需要
2、一般函数不能直接调用构造函数
3、构造函数如果前面加了 void 就变成了一般函数
4、构造函数中是有 return 语句的

一般函数和构造函数的区别

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化
一般函数：对象创建后，需要函数功能时才调用

构造函数：对象创建时，会调用只调用一次
一般函数：对象创建后，可以被调用多次

this

当成员变量和局部变量重名，可以用关键字 this 来区分
this 代表当前对象
this 就是所在函数所属对象的引用
代表当前类的引用对象（当前对象），哪个类的哪个对象调用方法，在方法内部的 this 就代表了调用方法的那个对象

应用场景：
1、解决了局部变量隐藏成员变量的问题
2、其实 this 还有其他应用，以后再讲

this 也可以用于在构造函数中调用其他构造函数
注意：只能定义在构造函数的第一行，因为初始化动作要先执行

Static

可以修饰成员变量和成员方法
特点：
1、随着类的加载而加载
2、优先对象的存在
3、被类的所有对象共享
4、可以通过类名调用
5、既可以被类名调用，也可以被对象调用，建议被类名调用
6、静态修饰的内容一般我们成为：类成员
7、静态的东西是放在方法区的静态区里
static 关键字的注意点：
1、在静态方法中不能使用 this 或者 super
2、静态方法是在加载类时创建并自检的，发现对象的东西是不可以的
3、静态方法只能访问静态变量和静态方法，不能访问非静态变量和非静态方法（静态只能访问静态）
4、非静态方法可以访问静态变量和静态方法，也可以访问非静态变量和非静态方法
5、私有方法加了静态也不能被访问
main 方法是静态的：
public：权限，最大权限
static：不用创建对象 就可以访问
void：返回值给JVM
main：主方法名JVM的入口
String[] args：数组，可以接受数组
例如：

class Person
{
	private String name;
	private int age;
	static String country = "CN";
	public Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public void show()
	{
		System.out.println(Person.country+":"+this.name+":"+this.age);
	}

	public static void method()
	{
		System.out.println(Person.country);
	}
}

class StaticDemo
{
	public static void main(String[] args) throws Exception
	{
		Person.method();

		Person p = new Person("java",20);
		p.show();
	}
}

成员变量和静态变量的区别

1、所属不同
静态变量：属于类，也可属于对象
成员变量：属于对象

2、内存位置不同
静态变量：方法区的静态区
成员变量：堆内存

3、生命周期不同
静态变量：随着类的加载而被加载，随着类的消失而消失
成员变量：随着对象的创建而存在，随着对象的消失而消失

4、调用不同
静态变量：可以通过类名调用，也可以对象名调用
成员变量：只能同过对象名调用

静态的使用

1、静态变量
当分析对象中所具备的成员变量的值都是相同的
这时这个成员就可以被静态修饰
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的

2、静态函数
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态
但是非静态需要被对象调用，而仅创建对象调用非静态的
没有访问特有数据的方法，该对象的创建是没有意义

代码块

在 Java 中，使用{}括起来的代码就叫代码块
根据位置不同和声明不同，可以分为：
局部代码块：局部位置（方法体里），用于限定变量的生命周期
构造代码块：在类中的成员变量（类中方法外）位置，每次调用构造方法的执行前，都会先执行构造代码块
作用：可以把多个构造方法的共同的代码放到里面
静态代码块：在类中的成员变量位置，只不过左大括号的前面加 static
作用：一般是对类进行初始化
代码块和构造方法的执行顺序：
静态代码块 > 构造代码块 > 构造方法
静态代码块执行一次
引用类型和方法块谁前谁先执行（除静态代码块）

题目

class Mother
{
	Candy c = new Candy();//引用类型成员变量

	static {
		System.out.println("Mother'S 静态代码块");
	}

	{
		System.out.println("Mother'S 构造代码块");
	}

	Mother(){

		System.out.println("Mother's 构造方法");

		{
			System.out.println("Mother'S 局部代码块");
		}

	}
}

class Candy
{
	Candy(){
		System.out.println("Candy's 无参构造方法");
	}
}

class Daughter extends Mother
{
	Candy cy = new Candy(); //引用类型成员变量
	//int i = 2; //基本类型成员变量

	Daughter(){
		System.out.println("Daughter's 构造方法");
	}

	public static void main(String[] args)
	{
		new Daughter();
	}
}

输出：
Mother's 静态代码块
Candy's 无参构造方法
Mother's 构造代码块
Mother's 构造方法
Mother's 局部代码块
Candy's 无参构造方法
Daughter's 构造方法

思路：
1、先走 mother 的静态代码块（static永远第一，因为随着类而加载，与对象无关）
2、再走 mother 里的成员变量初始化（因为不管是构造代码块，或者构造方法，或在普通的方法，全都有可能使用成员变量）
3、再走 mother 的构造代码块
4、再走 mother 的构造方法
5、再走 mother 的局部构造代码块
6、再走 daughter 里的成员变量初始化
7、再走 daughter 里的构造方法