Java基础面向对象

面向对象的三个特点：
1：将复杂的事情简单化。
2：面向对象将以前的过程中的执行者，变成了指挥者。
3：面向对象这种思想是符合现在人们思考习惯的一种思想。

面向对象的三个特征：
1.封装
2.继承
3.多态

对面向对象的理解：
面向对象中的对象一定要有特点特征。
当我们创造对象的时候，一个功能定义在对这个功能最清楚的对象中。
例如：（名词接对象） “人开门” 这个示例，在这个示例中，门就是对象；人开门的过程中，开门这个功能就定义在们这个对象中。

对于事物的描述通常只关注两个方面：
1.属性（事物本身所属的数据）
2.行为（事物所做的，也就是通常所说的功能）
在类中定义其实都称之为成员。成员有两种：
1：成员变量：其实对应的就是事物的属性。
2：成员函数：其实对应的就是事物的行为。

类与对象的关系：
类：事物的描述。
对象：该事物的实例（在java中通过new来创建的）

注意：被一个类中的事物创建出来的对象，其对象的类型为这个事物的类的类型

示例：

Car c  = new Car()；

其创建过程在内存中运行先后顺序的分析：
1：先将硬盘上指定位置的Car.class文件加载进内存。
2：执行main方法，然后在main方法的栈区分配了一个变量c。
3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new
4：在该实体空间中进行属性的空间分配，并进行了默认初始化。
5：对空间中的属性进行显示初始化。
6：进行实体的构造代码块初始化。
7：调用该实体对应的构造函数，进行构造函数初始化。（）
8：将首地址赋值给c ，c变量就引用了该实体。(指向了该对象)

理解：一旦由一个类创建出来了一个新的对象，则对象就具备了该类中所有的内容。

成员变量和局部变量的区别：
1（权限）：成员变量定义在类中，整个类都可以访问。
局部变量定义在方法中，参数上，语句中。只有所属区域的{}中才有权限访问

2（存在的地方）：成员变量存在于堆内存中。
局部变量存在于栈内存中，

3（生命周期）：成员变量随着对象的产生而存在，消失而消失。
局部变量存随着所属区域的运行而存在，结束而释放。

4（初始化值）：成员变量都有默认初始化值。
局部变量没有初始化值。

//示例：(假如此代码存在于局部代码块中，为局部变量)int a = 3;int b = 3;

其数据的存储，存储在栈内存中，而栈内存中的数据是可以共享的。
栈中数据共享内存分析：编译器先处理 int a = 3，首先会再栈中创建一个变量为a的引用，然后在栈中查找是否有了这个值，如果没有找到就将3存放进来，然后将a指向3.
接着，处理 int b，创建完b的引用变量后，因为栈中已经有3这个值，便将b指向了3.
这样就出现了a，b同时指向3的情况。
如果再令 a = 4，编译器就会在栈中重新搜索是否有4这个值，若有，就将a指向这个地址，若没有，则将4存放进来，并令a指向4，因此a值得改变不会影响b值。

注意：而在面向对象中，两个对象的引用同时指向一个对象的这种共享中，若一个对象引用变量修改了这个对象的内部状态，则会影响到另一个对象引用变量。

匿名对象：
示例：new Car();
理解：没有名字的对象,就是对定义对象的简写格式。

匿名对象的使用：
1：当对方法只进行一次调用的时候，可以使用匿名对象。
2：匿名对象可以作为实际参数进行传递。
示例：show（new Car（））；

匿名对象使用注意：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。

构造函数：用于给对象进行初始化，是具有针对性的。
特点：
1：该函数的名称和所在类的名称相同。
2：不需要定义返回值类型。
3：该函数没有具体的返回值

注意：1.所有对象创建时，都需要构造函数的初始化。
2.理解并记得默认构造函数的特点。
3.多个构造函数是以重载的形式存在的。

假如一个类中没有定义过构造函数的话：
一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数的构造函数。

假如一个类中定义了指定的构造函数的话：
如果在类中定义了指定的构造函数，那么类中原本默认的空参数的构造函数就没有了。

构造函数和一般函数的区别：
1. 构造函数：在对象创建是就会调用与之对应的构造函数对对象进行初始化。
一般函数：对象创建后，需要函数功能时调用

1. 构造函数：对象创建时调用，并且只调用一次
   一般函数：对象创建后调用，可调用多次

什么时候需要定义构造函数呢？
在创建对象时，对象就就被一些内容，然后就将这些内容定义在构造函数中。

注意：
1. 构造函数可以调用一般函数，而一般函数必须要创建对象初始化时才可以调用构造函数
2. 构造函数名首字母大写，一般函数首字母小写
3. 创建对象时只可以调用构造函数，不可以调用与构造函数同名的一般方法。
4. 构造函数代码块末有return语句

封 装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：1.将变化隔离。
2.便于使用。
3.提高重用性。
4.安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

private:私有，只有在本类中的访问有效,用于修饰成员

注意：私有仅仅是封装的一种体现形式而已。
封装：再比如Java中的函数也是一种封装

this:代表对象。就是所在函数所属对象的引用，可以那么理解：哪个对象调用了this所在的函数，那么this就代表哪个对象。

调用格式：this(实际参数)；

this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；

this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

注意：
1. 当局部变量和成员变量重名时，可以使用this关键字来区分
2. 用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要最先执行。

static： 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

static特点：
1，想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
2，被静态修饰的成员，可以直接被类名所调用。
3，静态随着类的加载而加载。而且优先于对象存在。

static的不足：
1，对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
2，静态方法只能访问静态成员，不可以访问非静态成员。
因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
3，静态方法中不能使用this，super关键字。
因为this代表对象，而静态在时，有可能没有对象，所以this或者super无法使用。

成员变量和静态变量的区别：
1. 成员变量：随着对象的创建而存在，随着对象的消失而消失
静态变量：随着类的加载而存在，随着类的消失而消失。

1. 成员变量：存在于堆内存中
   静态变量：存在于静态方法区中

   1. 成员变量：只能被对象调用
      静态变量：除了能被对象调用之外，还能被类调用

   2. 成员变量：所属于对象。所以也称为实例变量。
      静态变量：所属于类。所以也称为类变量。

静态变量什么时候使用：
对象中所具备的某个成员变量的值都是相同的，那么就将次变量设置为静态的，如果数据在对象中都是不同的，那么此数据就是对象的特有数据，就不能将其设置为静态。

静态函数什么时候用：
该函数中是否访问到了对象中的特有数据，如果没有访问到对象中的特有数据，那么就将此函数设置为静态函数，反之则不能设置为静态函数。

注意：静态函数可以不定义成静态函数，则为非静态函数，那调用时需要创建对象，而此对象并没有访问特殊数据，那么该对象的创建是没有意义的，且浪费内存空间。

静态代码块：随着类的加载而加载
作用：用于给类初始化（不是所有类都是通过构造函数去初始化的）

构造代码块：可以给所有对象进行初始化。

构造代码块和构造函数的区别：
构造代码块是给所有的对象进行初始化，而构造函数是针对性的给对象进行初始化。

单例设计模式
解决的问题：保证一个类在内存中的对象唯一性。

如何保证对象唯一性呢？
1，不让其他程序创建该类对象。
2，在本类中创建一个本类对象。
3，对外提供方法，让其他程序获取这个对象。

步骤：
1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；
2，就在类中创建一个本类的对象；
3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

//饿汉式class Single{    //私有化构造函数。    private Single(){}     //创建私有并静态的本类对象。   private static Single s = new Single();    //定义公有并静态的方法，返回该对象。    public static Single getInstance(){         return s;    }}

“`
//懒汉式:延迟加载方式。
class Single2{
private Single2(){}
private static Single2 s = null;
public static Single2 getInstance(){
if(s==null)
s = new Single2();
return s;
}
}