Java基础第二遍-06-面向对象

面向对象

1. 特点：
   1. 面向对象是一种常见的思想，符合人们的思考习惯
   2. 面向对象的出现，将复杂的问题简单化
   3. 面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者
2. 特征：
   1. 继承
   2. 封装
   3. 多态
3. 对象的创建
   1. 通过new创建

类

1. 对生活中的事物进行表示，在Java中是通过类来描述的
2. 怎么描述呢？
   1. 通常只关注两点，一个是属性，一个是行为
3. 对象是类的具体实现（实例）
4. 成员变量就是属性，成员变量定义在类中

对象创建过程

1. 

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

1. 成员变量定义在类中，整个类中都可以访问
2. 局部变量定义在方法、代码块、语句中，只有所属区域有效
3. 成员变量存在于堆内存中
4. 局部变量存在于栈内存中
5. 成员变量随着对象的创建而存在，对象的消失而消失
6. 局部变量随着所属区域的存在而存在，随着所属区域的消失而消失
7. 成员变量会有默认初始化值
8. 局部变量没有默认初始化值

匿名对象

1. 创建：new Car();
2. 匿名对象可以作为实际参数进行传递

封装(Encapsulation)

1. 封装：隐藏对象的属性和实现细节，仅对外提供公共的访问方式
2. 优点：
   1. 将变化隔离
   2. 便于使用
   3. 提高重用性
   4. 提高安全性
3. 封装原则
   1. 将不需要对外提供的内容隐藏起来
   2. 将属性隐藏，对外提供公共方法进行访问（get set）已经形成规范

构造函数

1. 特点
   1. 函数名与类名相同
   2. 不用定义返回值类型
   3. 没有具体的返回值
   4. 无参构造默认存在
   5. 如果手动创建了构造函数，那么默认的无参构造将不存在
   6. 只在对象创建的时候调用一次
   7. 可以使用void进行修饰 和 可以使用return进行结束
2. 作用
   1. 给对象进行初始化（对象创建时，就会调用对应的构造函数）
3. 注意
   1. 默认构造函数的特点
   2. 存在多个构造函数时是以重载的形式体现的

有参构造创建对象内存加载过程

1. 

关键字this

1. this：代表当前对象，可以用于解决set方法设置属性成员变量和局部变量重名的情况，
2. 官方说法：this是所在函数所属对象的引用
3. this(name)相当于调用了Person(String name){this.name=name}---可以用于构造函数调用其他构造函数，但是只能定义在构造函数的第一行（因为初始化动作要先执行）

关键字static

1. 用于修饰成员（成员变量，成员函数）
2. 被修饰后的成员具有以下特点：
   1. 随着类的加载而加载
   2. 优先于对象存在
   3. 被所有对象共享
   4. 可以直接使用类名进行调用
3. 注意
   1. 静态方法只能访问静态成员
   2. 静态方法中不能写this，super关键字（因为static于创建对象之前存在）
   3. 主函数是静态的
4. static修饰的成员存在于内存的方法区中的静态方法区

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

1. 成员变量随着对象的创建而存在，对象的被回收而释放
2. 静态变量随着类的加载而存在，随着类的消失而消失
3. 成员变量只能被对象调用
4. 静态变量可以使用对象和类名进行调用
5. 成员变量别名：实例变量
6. 静态变量：类变量
7. 成员变量存在于堆内存的对象中，所以也叫对象的特有数据
8. 静态变量数据存储在方法区中的静态方法区，所以也叫对象的共享数据
9. 静态变量前面是类名，类名.静态变量
10. 成员变量前面是this，this.成员变量

程序运行内存加载图解

什么时候使用静态修饰符

1. 对于变量，不是对象特有的数据时 可以使用static进行修饰
2. 对于函数，函数的执行不涉及对象特有的数据时，可以使用static进行修饰

静态代码块

1. 定义：static{}
2. 特点：随着类的加载而执行，只执行一次

构造代码块（类中）

1. 
2. 随着对象的创建而加载，可以给所有的对象进行初始化

局部代码块（方法中）

1. 用于固定局部变量的生命周期

私有构造函数

1. 
2. 对于一个类中所有的类都为静态方法，那么就默认他不需要创建对象，可以将其构造函数进行私有化

文档注释

1. @author
2. @version 1.0
3. @param
4. @return
5. 需要生成文档的类，需要使用public修饰符进行修饰
6. 私有权限的方法生成文档的时候不会存在

单例设计模式

1. 解决问题：类在内存中的对象唯一性
2. 应用场景：必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性
3. 自己创建一个静态的对象，并且私有化构造函数其他类创建对象的方式

class S{
	private static S s = new S();
	private S(){}
	public static S getInstance(){
		return s;//提供对外访问的方法 可以控制是否返回对象
	}
}

4. 单例模式-内存图解
5. 单例设计模式实现的两种方式（饿汉式 懒汉式）

//单例设计模式---饿汉式
//类一加载对象就存在了
class S1{
    private static S1 s1 = new S1();
    private S1(){}
    public static S1 getInstance(){
        return s1;
    }
}
//单例设计模式---懒汉式
//特点：类加载的时候不创建对象，调用getIntance方法的时候才创建对象
//多线程并发访问的时候可能会造成不能保证对象唯一性的情况
class S2{
    private static S2 s2=null;
    private S2(){}
    public static S2 getInstance(){
        if (s2==null)
            s2=new S2();
        return s2;
    }
}