面向对象OOP复习（Object Oriented Programming）

1.1概念：

        所谓的面向对象是一种编程思想，通过这种思想可以把复杂的事情变得简单化，从原来的执行者变成指挥者，面向对象是基于面向过程而言的。

         面向过程强调的是过程，面向对象强调结果。

1.2三大特征

        1，封装性，把相关的数据封装成一个“”类“”组件

        2.继承性，是子类自动共享父类属性和方法

        3.多态，增强软件的灵活性和重用性

1.3类和对象

java语言最基本单位就是类，是一类事物的抽象，可以理解为模板或者设计图纸

每个对象有三个特点，状态、行为、标识

                状态：用来描述对象的基本特征

                行为：用来描述对象的功能

                标识：是指对象在内存中都有一个唯一的地址用来和其他对象区分

类是一类事物的抽象，对象是具体的实现。

        通过类来描述事物，把事物的属性当做成员变量，行为当做成员方法

通过class关键字创建类，通过new关键字创建对象。

1，一般来讲局部变量存在栈中，方法执行完毕内存就被释放

2.对象（new出来的）存在对重，对象不再被使用时内存才会被释放

3.每个堆内存的元素都有地址值

4，对象中的属性都是有默认值的

1，栈内存中，创建一个引用变量P，持有对象的地址值

2.堆内存中，创建Person对象，并且开辟变量空间，完成初始化

3.堆内存的元素会被分配一个唯一地址值，交给P（栈）保存

4，p.name="a";p.age="b"就是去堆内存中找地址值，找到Person对象并对其属性进行修改赋值

5.p.eat()就是去堆内存中找唯一的地址值，找到Person对象，执行Person对象的方法

6，只要有new就会开辟新的空间在堆内存存入对象，栈内存存入地址值。栈内存（先进后出）

封装

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

好处：提高安全性、重用性

private关键字是一个权限修饰符，用于修饰成员变量和成员函数，被私有化后只能在本类中访问

        想修改只能提供get和set方法

构造方法

与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成的

功能：完成对象的创建或者对象的初始化。当类实例化一个对象是会自动调用构造方法

当存在一个含参构造时，无参构造将不会自动生成。

创建对象的流程（Person p=new Person();为例）

1.把Person.class文件加载进内存

2.在栈内存中开辟空间存放变量p

3，在堆内存中开辟空间存放Person对象

4，对成员变量进行默认初始化

5，对成员变量进行显示初始化

6.执行构造方法（如果有构造代码块，先执行构造代码块在执行构造方法）

7，堆内存完成创建

8.把堆内存的地址值赋给变量p，p就是一个引用变量，引用了Person对象的地址

匿名对象（new Person（）；）

当被调用的对象只调用一次时（多次创建多个对象浪费内存）

构造代码块

类里方法外，每次创建对象都会被调用

通常用于抽取构造方法中的共性代码

每次调用构造方法前都会调用构造代码块

优先于方法加载

局部代码块

方法里面的代码块，方法被调用时才会执行

通常用于控制变量的作用范围，出了括号就失效

变量的范围越小越好，成员变量会有线程安全问题

静态代码块

在类加载时就加载，并且只被加载一次，一般用于项目的初始化

代码块执行顺序

父类静态变量→父类静态代码块→子类静态变量→子类静态代码块→父类构造代码块→父类构造方法→子类构造代码块→子类构造方法

this关键字

this代表本类对象的一个引用对象，构造函数中，this（）必须放在第一行。当局部变量和成员变量同名时，用于区分。

访问控制符

 public > protected >  default > private 

继承

概念：继承是面向对象最显著的一个特征，从已有的类派生出新的类，新类吸收了已有类的数据属性和行为i，并能扩展新的能力。

优点：使得复用以前代码非常容易，能大大缩短开发周期，降低开发费用，提高复用性

特点：1 使用extends关键字

            2 相当于子类把父类功能能复制了一份

            3.JAVA只支持单继承

            4，继承可以传递

            5.不能继承父类私有成员

            6.继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展

 super关键字  

1.通过super关键字可以使用父类的内容

2.super代表父类的一个引用对象。

3 如果用必须出现在调用位置的第一行

方法重写

父类中的私有方法不能被重写

子类重写父类方法修饰符要大于等于父类修饰符的权限。 

static

Java中的一个关键字，用于修饰成员（成员变量和成员方法）

特点：

1.可以修饰成员变量，成员方法

2.随着类的加载而加载，优先于对象加载

3，只加载一次就会一直存在，不再开辟新空间

4，全局唯一，全局共享，可以直接被类名调用

5，静态只能调用静态，非静态可以随意调用静态

6.static不能和this或者super共用，因为有static时可能还没有对象

final关键字

概念：最终的意思，可以修饰类，方法，成员变量

特点：

1.被final修饰的类不能被继承

2.被final修饰的方法不能被重写

3.被final修饰的变量是个常量，值不能被修改

4，常量的定义形式：final 数据类型 常量名=值

多态

概念：同一个实体同时具有多种形式。主要是指同一个对象在不同时刻，代表的对象不一样

好处：1.可以把不同子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准

        2，可以不用关心某个对象到底时什么具体类型，就可以使用该对象的某些方法

        3，提高了程序的扩展性和可维护性

特点：多态的前提时继承，要有方法的重写，父类引用指向子类对象，多态中编译看左运行看右，

成员变量使用的是父类的，存在重写成员方法，成员方法使用子类的，静态成员随着对象而存在，谁调用就返回谁。

静态变量和实例变量的区别

语法定义：静态变量前要加static,实例变量不加

程序运行时：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量属于类，也被称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

向上转型和向下转型

向上转型：父类引用指向子类对象

子类对象当成父类对象，只能调用父类功能，如果子类重写了父类的方法就引用指向调用子类重写方法

向下转型：子类的引用指向父类对象，过程采用强制转换。相当于创建了一个子类对象，可以用父类的也可以用自己的

向下转型时，是为了方便使用子类的特殊方法，当子类做了功能拓展，就可以直接使用子类功能

抽象类

特点：

1.通过Java关键字abstract实现

2.可以修饰方法或者类

3，抽象类中可以没有抽象方法（由子类去实现）

4，如果类中有抽象方法，该类必须定义为一个抽象类

5，子了继承了抽象类后，要么还是一个抽象类，要么把所有抽象方法重写

6，多用于多态中，抽象类不可以被实例化

7，抽象类有构造方法，但不能本身实例化，一般用于给子类实例化

8，既可以有变量，也可以有常量，既可以有普通方法，也可以有抽象方法

接口

特点：

1.接口中都是抽象方法，通过interface创建接口，通过implements让子类实现

2，接口突破了Java的单继承的局限性。接口和类之间可以多实现，接口和接口之间可以多继承,继承的同时多实现（先继承后实现）

3.接口时对外暴露的规则，是一套开发规范

4，提高了程序的功能扩展，降低了耦合性

5，接口中没有构造方法，在创建实现类的对象时默认的super()调用的默认Object的无参构造

6.接口中没有成员变量，都是常量，默认加public static final

7，接口中的方法，默认都是抽象方法，自动补齐abstract

设计模式

Java中有23种设计模式，本质是面向对象设计原则的实际运用，是对类的封装性 、继承性和多态性以及类的关联关系和组合关系的充分理解

单例设计模式概念：

确保对象只有一个，保证一个类在内存中的对象就一个。

饿汉式：

目的：控制外界创建对象的个数只能创建一个对象

开发步骤：

1.私有化构造方法

2.在类的内部创建好对象

3.对外界提供一个公共的get（），返回一个已经准备好的对象

public class Test_Single{
    public static void main(String[] args){
        Single s=Single.get();
        Single s1=Single.get();
//get()多少次，内存中使用的都是同一个对象
       System.out.println(s);//cn.tedu.single.Single@15db9742
       System.out.println(s1);//cn.tedu.single.Single@15db9742
    }
}
class Single{
//私有化构造方法
    private Single(){}
//创建对象
    static private Single s=new Single();
//对外界提供一个公共的get方法，返回一个已经准备好的对象
//static 为了外界不通过对象访问 通过类名直接访问
    static public Singel get(){
//静态只能调用静态
        return s;
    }
}

懒汉式：

class Single{
    //私有化构造方法，不让外界直接new
    private Singel(){}
//在类的内部创建好对象，静态只能调用静态
    static private Single s=null;
//对外界提供公共的get（），返回一个已经准备好的对象
    synchronized static public Single get(){
        if(s==null){
            s=new Single();//会有安全问题
        }
           return s;
    }
}

abstract注意事项

和一下关键字一起使用会发生矛盾

private：被私有化后，子类无法重写，与abstract相违背

static: 优先于对象加载，无法被重写，但是抽象方法需要子类重写。

final：被final修饰后无法重写

接口和抽象类的区别

成员区别：

抽象类可以有变量，常量，构造方法（用于子类实例化），可以有抽象方法也可以有非抽象方法

接口只能有常量（默认修饰符public static final），抽象方法（jdk1.8以后可以写以default和static开头的具体方法），没有构造方法

关系区别：

类与类 单继承

类与接口 可以单实现也可以多实现

接口与接口 继承，可以单继承也可以多继承

设计理念：

抽象类 对类抽象，包括行为属性

接口：主要对行为抽象

了解软件设计的开闭原则OCP（Open Close Principle ）

开放功能扩展，关闭源码修改。是Java世界里最基础的设计原则。

定义：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但对于修改时封闭的。

开，指的是可以在源代码的基础上进行扩展。在Java中之所以用继承，是在可以直接调用类库的前提下，对其功能进行扩展。不需要应用者去了解封装类的内部逻辑就可以做开发。

闭：指不允许对原有的代码进行修改，以免影响其他现有功能，造成功能瘫痪。

string字符串对象

特点：

是一个封装char[]数组的对象，字符串不可变

创建string对象：如果是第一次使用字符串，Java会在字符串常量池创建一个对象，再次使用相同的内容时，会直接访问常量池中存在的对象

StringBuilder/StringBuffer

特点：

1.封装了char[]数组，是可变的字符序列

2.提供了一组可以对字符内容修改的方法

3.常用append（）来替代字符串做字符串连接

4.内部字符数组默认初始容量是16，如果大于16会扩容，新数组大小变为原来的2倍加2，容量如果还不够直接扩充到需要的容量大小

String/StringBuilder/StringBuffer区别

String声明的是不可变的对象，每次操作都会生成新的String对象，然后指针指向新的String对象

StringBuilder、StringBuffer可以在原有对象的基础上进行操作。

	String	StringBuffer	StringBuilder
类是否可变	不可变（final）	可变	可变
功能介绍	每次对String操作都会在常量池中生成新的String对象	任何对它指向的字符串的操作都不会产生新的对象，字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，自动扩容	功能与StringBuffer相同，相比少了同步锁synchronized,执行速度更快
线程安全性	线程安全	线程安全	线程不安全
使用场景推荐	单次操作或者循环外操作字符串	多线程操作字符串	单线程操作字符串

包装类

与基本类型的对应关系

byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

自动装箱和自动拆箱

自动装箱：把基本类型包装成一包装类的对象

Integer a=5;//a是引用类型，引用了包装对象的地址。编译器会完成对象的自动装箱：Integer a=Integer.value(5);

自动拆箱：从包装对象中，自动取出基本类型值

int i=a;//a现在是包装类型，没法给变量赋值，需要把5取出来。编译器会完成自动拆箱

int i=a.intValue();