面向对象OOP(面向对象的三大特征)

面向对象三大特征:

1.封装:

1)类:封装的是对象的属性和行为

类中可以包含:

1.1)对象所共有的属性/数据--------------成员变量(属性)

1.2)对象所共有的行为/动作--------------方法(函数)

 

2)方法:封装的是具体的业务逻辑功能实现

        方法:函数、过程

       2. 1)封装一段特定的业务逻辑功能

        2.2)尽可能的独立，一个方法只干一件事

        2.3)可以被反复调用多次

       2. 4)减少代码重复，有利于代码的复用，有利于团队的协作

        2.5方法的定义:五要素

         修饰词 返回值类型 方法名(参数列表){

         方法体

        }

        2.6方法的调用:

        1)无返回值: 方法名(有参传参);

        2)有返回值: 数据类型 变量 = 方法名(有参传参

 

3)访问控制修饰符:封装的是具体的访问权限

3.1package:

3.1.1)作用:避免类的命名冲突

3.1.2)同包中的类不能同名，类的全称:包名.类名

3.1.3)包名可以有层次结构

3.1.4)建议:包名所有字母都小写 import:

3.2)同包中的类可以直接访问 不同包中的类不能直接访问，若想访问有如下两种方式:

3.2.1)先import声明类再访问类-----建议

3.2.2)类的全称-------------------太繁琐，不建议

3.3访问控制修饰符:-----------保护数据的安全

3.3.1)public:公开的，任何类

3.3.2)private:私有的，本类

3.3.3)protected:受保护的，本类、派生类、同包类

3.3.4)默认的:什么也不写，本类、同包类 说明:

3.4)类的访问权限只能是public或默认的

3.5)类中成员的访问权限如上4种都可以

 

2.继承:

     1)作用:代码复用

     2)通过extends来实现继承

     3)超类:所有派生类所共有的属性和行为 派生类:派生类所特有的属性和行为

     4)派生类继承超类后，派生类具有:派生类的+超类的

     5)一个超类可以有多个派生类 一个派生类只能有一个超类-------单一继承

     6)继承具有传递性

     7)java规定:构造派生类之前必须先构造超类 ----在派生类的构造中若没有调用超类构造，则默认super()调用超类无参构造 ----在派生类的构造中若调用了超类构造，则不再默认提供

2.1.接口:

1)是一种数据类型(引用类型)

2)由interface定义

3)只能包含常量和抽象方法

4)接口不能被实例化

5)接口是需要被实现/继承的，实现/派生类: 必须重写接口中的所有抽象方法

6)一个类可以实现多个接口，用逗号分隔 若又继承又实现时，应先继承后实现

7)接口可以继承接口

3.多态:

1)行为的多态:所有抽象方法都是多态的  (通过方法的重写来表现的 )

   对象的多态:所有对象都是多态的 (通过向上造型来表现的)

1)意义:

1.1)同一类型的引用，指向不同的对象时，有不同的实现 ----行为的多态:cut(),step(),getImage()...

1.2)同一个对象，被造型为不同的类型时，有不同的功能 ----对象的多态:我,你,水...

 

2.方法的重写(Override):重新写、覆盖

1)发生在父子类中，方法名相同，参数列表相同，方法体不同

2)重写方法被调用时，看对象的类型---这是规定，不需要理解

3)重写遵循"两同两小一大"原则:-----------了解

3.1)两同:

3.1.1)方法名相同

3.1.2)参数列表相同

3.2)两小:

3.2.1)派生类方法的返回值类型小于或等于超类方法的

1)void时，必须相同

2)基本类型时，必须相同

3)引用类型时，小于或等于

3.2.2)派生类方法抛出的异常小于或等于超类方法的

3.3)一大:

3.3.1)派生类方法的访问权限大于或等于超类方法的

 

3)向上造型/自动类型转换:

3.1)超类型的引用指向派生类的对象

3.2)能造型成为的数据类型有: 超类+所实现的接口

3.3)能点出来什么，看引用的类型

4)强制类型转换，成功的条件只有如下两种:

4.1)引用所指向的对象，就是该类型

4.2)引用所指向的对象，实现了该接口或继承了该类

5)强转时若不符合如上条件，则发生ClassCastException类型转换异常 建议:强转之前先通过instanceof来判断引用的对象是否是该类型

 

面向对象OOP其他内容:

2.方法的重载(Overload):-----调用起来方便,不需要记住很多方法名

1)发生在同一类中，方法名称相同，参数列表不同，方法体不同

2)编译器在编译时会根据方法的签名自动绑定方法

3.构造方法:(构造函数,构造器,构建器)----------------代码复用

1)给成员变量赋初值

2)与类同名，没有返回值类型(连void没有)

3)在创建(new)对象时被自动调用

4)若自己不写构造方法，则编译器默认提供一个无参的构造方法，

若自己写了构造方法，则不再默认提供

5)构造方法可以重载

 

3.重写与重载的区别:

1)重写:

1.1)发生在父子类中，方法名相同，参数列表相同，方法体不同

1.2)遵循"运行期绑定"，看对象的类型来调用方法(可以不答)

2)重载:

2.1)发生在同一类中，方法名相同，参数列表不同，方法体不同

2.2)遵循"编译期绑定"，看参数/引用的类型来绑定方法(可以不答)

 

this:指代当前对象，哪个对象调用方法它指的就是哪个对象

只能用在方法中，方法中访问成员变量之前默认有个this.

(是一个关键字,只能用在方法中)

this的用法:

1)this.成员变量名-----------访问成员变量

(当成员变量与局部变量同名时,访问成员变量的this不能省略)

2)this.方法名()-------------调用方法(一般不用)

3)this()--------------------调用构造方法(应用率低)

 

super:指代当前对象的超类对象

super的用法:

1)super.成员变量名-----访问超类的成员变量

2)super.方法名()-------调用超类的方法--------明天下午讲

3)super()--------------调用超类的构造方法

 

3.final:最终的、不可改变的-----单独应用率极低

1)修饰变量:变量不能被改变

2)修饰方法:方法不能被重写

3)修饰类:类不能被继承

4.static:静态的

1)静态变量:

1.1)由static修饰

1.2)属于类，存储在方法区中，只有一份

1.3)常常通过类名点来访问

1.4)何时用:所有对象所共享的数据(图片、音频、视频等)

2)静态方法:

2.1)由static修饰

2.2)属于类，存储在方法区中，只有一份

2.3)常常通过类名点来访问

2.4)静态方法中没有隐式的this传递，所以不能直接访问实例成员

2.5)何时用:方法的操作与对象无关

3)静态块:

3.1)由static修饰

3.2)属于类，在类被加载期间自动执行，

因类只被加载一次，所以静态块也只执行一次

3.3)何时用:加载/初始化静态资源(图片、音频、视频等)

 

 

1.static final常量:

1)必须声明同时初始化

2)通过类名点来访问，不能被改变

3)建议:常量名所有字母都大写，多个单词用_分隔

4)编译器在编译时会将常量直接替换为具体的值，效率高

5)何时用:数据永远不变，并且经常使用

2.抽象方法:

1)由abstract修饰

2)只有方法的定义，没有具体的实现(连大括号都没有)

3.抽象类:

1)由abstract修饰

2)包含抽象方法的类必须是抽象类

3)抽象类不能被实例化(实例化就是new对象)

4)抽象类是需要被继承的，派生类:

4.1)重写所有抽象方法--------变不完整为完整

4.2)也声明为抽象类----------一般不这么用

5)抽象类的意义:

5.1)封装共有的属性和行为------------代码复用

5.2)为所有派生类提供统一的类型------向上造型

5.3)可以包含抽象方法，为派生类提供统一的入口(能点出来)，

派生类的具体实现不同，但入口的是一致的

 

1.成员内部类: 应用率低，了解

1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类

2)内部类通常只服务于外部类，对外不具备可见性

3)内部类对象通常是在外部类中创建的

4)内部类中可以直接访问外部类的成员(包括私有的)

内部类中有个隐式的引用指向了创建它的外部类对象

语法: 外部类名.this

2.匿名内部类: 大大的简化代码

1)若想创建一个类(派生类)的对象，并且对象只创建一次，

此时该类不必命名，称之为匿名内部类

2)匿名内部类中若想访问外面的变量，该变量必须是final的(JDK1.7(含)以前的要求)

 

 

1.内存管理:由JVM来管理

1)堆:

1.1)存储new出来的对象(包括实例变量)

1.2)垃圾:没有任何引用所指向的对象

垃圾回收器(GC)不定时到内存堆中回收垃圾，

回收过程是透明(看不到的)的，不一定一看到垃圾就立刻回收，

通过调用System.gc()建议JVM尽快调度GC来回收

1.3)实例变量的生命周期:

创建对象时存储在堆中，对象被回收时一并被回收

1.4)内存泄漏:不再使用的内存还没有被及时的回收

建议:不再使用的对象及时将引用设置为null

2)栈:

2.1)存储正在调用的方法中的局部变量(包括方法的参数)

2.2)调用方法时，会在栈中为该方法分配一块对应的栈帧，

栈帧中存储局部变量(包括参数),

方法调用结束时，栈帧被自动清除，局部变量一并被清除

2.3)局部变量的生命周期:

调用方法时存储在栈中，方法调用结束时与栈帧一并被清除

3)方法区:

3.1)存储.class字节码文件(包括静态变量、方法)

3.2)方法只有一份，通过this来区分具体的调用对象

 

方法外-------------成员变量

成员变量分两种:

1)实例变量:没有static修饰，属于对象，存储在堆中， 有几个对象就有几份 通过对象名点来访问

2)静态变量:由static修饰，属于类，存储在方法区中， 只有一份 通过类名点来访问

方法中-------------局部变量