java面向对象编程在我看来共三部分

一、类及类的成员：属性、方法、构造器、代码块、内部类、（枚举类、接口、注解、

       包装类、Object类）

二、面向对象三大特征：封装、继承、多态

三、其他关键字的使用：权限修饰符（public > protected > 缺省 >private）、

this、super、extend、abstract、interface、implement、static、final等

1.属性：

        1.1声明格式：权限修饰符  +  （static） + （final） +  变量类型  +  变量名 （= 初始化值）；

                注：接口中声明的变量类型均为 public static final + 变量类型 + 变量名 （= 初始化值）

                        即接口中定义的变量按常量处理一般大写字母表示

        1.2变量分类：（还可以按数据类型分为基本数据类型和引用数据类型在此不过多关注）

                成员变量：

                        实例变量（不用static修饰）：

                        ①先声明后使用

                        ②随着对象的创建产生，内存分配在堆空间

                        ③可采用默认初始化，也可采用显示初始化、代码块初始化、构造器初始化

                        ④对应一个对象一份实例变量，通过对象.属性调用及赋值

                        ⑤可声明 权限修饰符、final修饰符

                        类变量（static修饰）：

                        ①先声明后使用

                        ②类中声明、内存分配在方法区内

                        ③可采用默认初始化，也可采用显示初始化

                        ④对应一个类一份类变量，通过类.属性调用及赋值

                        ⑤可声明 权限修饰符、final修饰符（public static final 全局常量）

                局部变量：

                        ①先声明后使用

                        ②可以声明在方法体、方法形参、构造器内、构造器形参、代码块内、内部类内

                        ③内存分配在栈空间内，与方法体等生命周期相同

                        ④可默认初始化和显示初始化（形参不可默认初始化）

                        ⑤可声明final修饰符，没有权限修饰符、权限跟随方法构造器等结构

        1.3属性赋值顺序：默认初始化 > 显示初始化 / 代码块内初始化（谁在上谁先执行）>

             构造器初始化 > 类.属性 对象.属性赋值

2.方法：

        2.1声明格式：权限修饰符 + void / 变量类型 + 方法名 （形参列表）

                {方法体    （return + 返回值类型）}；方法内可以有属性

                注：方法内不能写方法但可以声明内部类

        2.2方法的递归

                ①方法的递归包含了一种隐式循环，重复执行某段代码

                ②递归一定要向已知方向递归，否则就会变成死循环

        2.3方法的值传递

                ①形参是基本数据类型，传递其具体数值

                ②形参是引用数据类型，传递其地址值，具体数值在堆中

        2.4方法的调用

                ①非静态方法必须创建对象，采用对象.方法的形式调用

                ②静态方法可以采用类.方法 / 对象.方法形式调用

        2.5方法的重载@overload（两同一不同）

                ①方法名必须相同

                ②重载方法必须在同一个类中

                ③形参列表必须不同（顺序、数量、类型满足一点即可）

                ④修饰符、返回值类型等不作要求

        2.6方法的重写@override

                ①方法名、形参列表必须相同

                ②重写方法的访问权限不小于父类方法的访问权限（父类private方法不能被重写）

                ③重写方法的返回值类型基本数据类型必须相同，引用数据类型不能大于父类方法

                ④重写方法必须不在同一个类，存在于子父类（extend）、接口类（implement）

                ⑤重写时父类或接口中方法有static必须重写为static，没有static不可重写为static

3.构造器

        3.1声明格式：权限修饰符  + 构造器名 （形参列表）{方法体}；构造器内可以

                有属性、方法

                注①：在一个类中如果不声明构造器idea默认生成该类无参构造器（不显示）如果

                        主动声明了构造器则该构造器消失    

                注②：构造器都会默认声明super（）；在构造器的第一行（不显示）若主动添加

                        this. / super. 后默认super（）失效，所有构造器第一行都声明了this. / super.

        3.2构造器的作用：创建类的对象，初始化类的对象    

        3.3构造器直接可以形成构造器重载

                ①构造器名与类名相同

                ②构造器形参列表必须不同

                ③构造器权限修饰符可以不同

        3.4抽象类（abstract）也有构造器，但是不可实例化，子类继承时调用

        3.5 private构造器：

                具体应用于单例模式（懒汉式 / 饿汉式），保证某个类只能有一个对象实例：

                private构造器和static的get类方法结合实现

4.代码块

        4.1声明格式: {} / static{}  代码块内可以有属性、方法

        4.2代码块的作用：初始化类、对象信息

        4.3代码块分类：

                静态代码块：

                        ①static关键字修饰

                        ②随着类的加载而加载因此只被加载一次，初始化类的加载信息

                        ③内部只能调用静态成员变量和方法

                非静态代码块：

                        ①随着对象的创建而加载，一个对象加载一次，初始化对象信息

                        ②内部可调用本类的所有成员变量和方法

                相同点：

                        ①均可有输出语句

                        ②如果定义多个静态或非静态代码块均按顺序依次执行

5.内部类

        5.1声明格式：修饰符 + 类名 {}

        5.2定义：在一个类A内部定义一个新类B，A为外部类，B为A的内部类

        5.3内部类分类（参考变量分类）：

                从类的角度看，可以声明属性、方法、构造器、代码块、内部类，可以被abstract、

                final修饰，可以声明父类、接口，从外部类属性角度来看，可以被权限修饰符、

                static、final、private、protecte修饰

                成员内部类

                        ③静态成员内部类：随着类的加载而加载，只加载一次

                        ④非静态成员内部类：随着对象的创建而加载，一个对象加载一次

                局部内部类

                        ①声明在方法、构造器、代码块内

                        ②掌握匿名类的匿名对象调用方法

                               举例：定义一个接口，在类A中写一个返回接口类型的方法，在方法中定义

                                局部内部类B implement 这个接口， return new 接口名（）{接口方法重写}          

6.封装

        6.1封装的体现

                狭义上：

                        ①私有化（private）类的属性，提供公共的（public）方法去实现设置获取属性

                        ②如果类中的方法不希望被其他类调用，可以将权限设置成private

                        ③如果类中的方法不希望被其他包的类调用，可以权限设置为缺省

                        ④如果类中的方法不希望被其他包下非该类子类的类调用，权限设置为protected

                        ⑤单例模式：private构造器、private、static对象、static get（）方法

                广义上：

                        ①为了实现高内聚低耦合，提供四种权限修饰符，把该隐藏的隐藏起来

                        ②权限修饰符比较：

7.继承

        7.1声明格式：class A extends B       

        7.2继承性说明：

                ①子父类是相对的，父类又继承于他的父类，所有类有一个共同的父类lang包下的object

                ②子类通过继承可以获得父类及所有间接父类属性和方法        

                ③子类获取父类的方法由于封装性，无法全部调用，private修饰的属性方法无法调用

                ④子类没有多继承，一个子类只能有一个父类（但是可以有多接口，单继承的完善）

                ⑤提供拓展性，使类与类之间产生联系，提供多态基础

        7.3继承的内存分析

                创建一个子类对象过程中，父类及间接父类的super（）均会被调用，并且因为加载

                了这些父类构造器，父类的属性方法子类均可调用，但在子类对象实例化的过程中，只

                创建了一个对象，即子类对象

8.多态

        8.1定义：一个事物的多种形态，多态使用前提是必须有类的继承关系

        8.2声明格式：A a = new B（）；（注：B 必须是 A 的子类）

        8.3多态的体现：

                ①方法的重载和重写（overload & override）

                ②子类对象的多态性

        8.4虚拟方法调用

                编译时认为调用的方法是父类的，运行时实际执行的是子类的方法

                即编译看左运行看右

        8.5 instanceof对象的上下转型

                向上转型：

                        向上转型即为多态，例如：class A extends B

                向下转型：

                        ①由于子类的对象赋给父类的引用，导致虽然内存中有子类自己定义的方法方法

                        却无法使用所有因此需要向下转型

                        ②向下转型声明格式（以A a = new B（）为例）： B b = （B）a；

                        ③  为了避免Class Cast Exception异常，强转之前一般会用 a instanceof B判断

        8.6包装类

                作用：实现基本数据类型——>引用数据类型的转换，从而可以使用大量对象方法

                类型间转换：

                        ①自动装箱（以int ——> Integer为例）：int i； Integer ii = i；

                        ②自动拆箱（以Integer ——> int为例）：Integer i； int ii = i；

                        ③基本数据类型 / 包装类 —— >String类型：调用String的 valueof（）方法

                        ④String类型 —— >基本数据类型 / 包装类：调用包装类的 parseXxx（）方法

9.权限修饰符

        public、protected、缺省、private 体现java的封装性

10.this

        10.1语义：当前对象的

        10.2调用：

                ①成员变量（this.属性）

                ②方法（this.方法）

                ③构造器（this（形参列表））必须声明在首行

11.super

        11.1语义：父类的

        11.2调用：

                ①成员变量（super.属性）

                ②方法（super.方法）

                ③构造器（super（形参列表））必须声明在首行

        关于super() 和 this()：在一个类的每一个构造器中首行一定调用到了this或super，一个        

        类中假设有n个构造器，至多有n-1个可以调用this()，必须有一个构造器调用父类构造器

        如果构造器首行没有显示调用this或super，则默认调用super()

12.extends

        12.1语义：继承

        12.2修饰：

                ①类（class A extends B）

                ②内部类 （class A extends B）

13.abstract

        13.1语义：抽象的

        13.2修饰：

                ①类（abstract class A）

                ②方法（权限修饰符+abstract+返回值类型+方法名（）；）

                ③内部类（abstract class A）

14.interface

        14.1语义：接口

        14.2修饰：接口（interface A）

        14.3使用说明：接口中只能定义常量和方法

                ①属性均用 public static final修饰 

                ②方法一般用 public abstract 修饰

                ③可以定义静态方法（public static void）只能被接口本身来调用

                ④可以定义默认方法（public default void）可以被实现类继承，实现类没有重写        

                默认调用接口中声明的default方法，如果实现类实现两个接口中有同名的default

                方法在实现类没有重写的前提下会报错

                ⑤可以定义私有方法（private void）

                ⑥类可以用implement获取接口，获取后可重写接口中的所有抽象方法 / 定义为抽象类

15.implements

        15.1语义：连接

        15.2修饰：

                ①类（class A implement B）

                ②内部类（class A implement B）

16.static

        16.1语义：静态的

        16.2修饰：

                ①成员变量（static+数据类型 a）被类的所有对象共享通过class.调用，也可被对象调用

                ②方法（权限修饰符 + static+（final）+返回值类型+方法名（）{}   静态方法内可以调用

                类变量和静态方法，非静态方法可以调用非静态属性方法也可调用静态属性方法

                ③代码块（static{}）随着类的加载而加载

                ④内部类（static class A）随着类的加载而加载

        16.3使用环境：

                ①对于属性当需要类中多个对象共享时建议声明为static类型

                ②对于方法若要操作静态变量则须声明为static类型

17.final

        17.1语义：最终的

        17.2修饰：

                ①成员变量（final +数据类型 a）表示一个常量

                ②方法（权限修饰符+（static）+final + 返回值类型+方法名（）{}）该方法不能被重写

                ③类（final class A）不能被继承

18.instanceof

        18.1作用：判断（a instanceof A）左边对象是否为右边类的直接或间接对象

        18.2使用场景：多态对象的向下转型，转型之前先判断（a instanceof A）

19.object类 

        19.1说明：  object类是所有类的根父类，其内只定义Objcet()构造器，内部定义的方法适用任

                            何子类（包括数组）

        19.2常用方法：

                equals():   定义：public boolean equals(Object obj) {

                                            return (this == obj);}

                ①作用即为比较两个对象地址值是否相等

                ②String、Date、File、包装类等包下重写object的equals方法为比较实体内容是否相等

                ③对于自定义类来说如果没有重写equals方法比较的还是两个对象的地址值是否相等

                ④一般情况下自定义类都会重写equals方法使其比较对象属性是否相等

                toString()： 定义：public String toString() {

                                              return getClass().getName() + "@" +

                                              Integer.toHexString(hashCode());}

                ①作用即为打印一个对象名及其地址值

                ②String、Date、File、包装类等包重写该方法使其返回对象的具体内容

                ③对于自定义类来说没有重写该方法还是返回对象地址值

                ④一般情况下自定义类均会重写该方法使其返回对象的属性信息

20.枚举类（Enum）

        说明：

                ①本质上也是一种类，不过类中的对象是固定的有限的

                ②使用Enum关键字定义枚举类，默认其父类是lang包下的Enum

                ③必须在枚举类开头声明多个枚举对象，对象之间用“，”隔开        

                ④枚举对象均用public static final + 类名声明，且“public static final + 类名”省略

                ⑤声明对象后声明变量、构造器、方法等结构，成员变量用private final修饰

                    构造器用private修饰

        常用方法：

                ①String toString()方法被重写，默认返回对象名，可继续手动重写

                ②String name()方法得到当前枚举常量（对象）的名称，建议优先使用toString

                ③int ordinal()方法返回当前枚举常量的次序号，默认从0开始

21.注解

        说明：

                ①以“@注解名”在代码中存在

                ②可以像修饰符一样使用，修饰包、类、构造器、方法、成员变量、参数、局部变量的

                    声明，还可以添加一些数值，数值被保存在Annotation的“name = value”中

                ③注解可以在类编译运行时进行加载，体现不同功能

        JavaSE常用注解：

                ①'override'：重写父类方法，该注解只能用于方法

                ②'Deprecated'：用于表示所修饰的元素（类、方法等）已过时

                ③'SuppressWarnings'：抑制编译器警告