目录

面对象基础 

对象

类

类与对象的关系

类的编写

类的组成

this

对象的创建过程

匿名对象

 面向对象三大特征

 封装

 继承

多态

 三大修饰符

1.抽象的

 2.最终的

3.静态的

代码块

面对象基础 

对象

描述一个真实存在的事物

类

多个对象抽取其共同点形成的一个概念

创建对象：

        语法：

                类名 对象名=new 类名(实参列表);                

类与对象的关系

生活中：先有对象后有类

Java中：先有类后有对象，

                一个类可以有多个对象，

                多个对象可以同属一个类

类的编写

语法:

        访问权限修饰符 class 类名{

        }

访问权限修饰符:public

类的组成

属性:        

        别名:成员变量;

        本质:类内方法外定义的变量

        定义格式:

                访问权限修饰符 数据类型 变量名;

构造函数:

        别名:构造方法;

        定义格式:

                访问权限修饰符 类名(形参列表){

                        方法体;

                }

方法:

        别名:函数

        定义格式:

                访问权限修饰符 修饰符 返回值类型 方法名(形参列表){

                        方法体;

                        return xxx;

                }

this

概念:

        谁调用this所在的方法,this就是谁

使用:

        一般在成员变量和局部变量重名时,用于区分成员变量和局部变量,用this.变量名代表成员

        变量;

对象的创建过程

创建对象语法:

        类名 对象名=new 类名(实参列表);

创建过程:

        1.在堆内存中开辟一片运行内存,

        2.给对象属性赋初值

        3.执行构造函数中的代码

        4.将栈中的引用指向堆中开辟的地址

匿名对象

概念:没有对象名的对象

语法:

        new 类名(实参列表)

 缺点:

        只能使用一次

        导致代码结构混乱

 面向对象三大特征

 封装

思想：包装

优点：

        1.美化

        2.降低耦合度

        3.保护内部

        4.方便使用

java代码中的封装：

        变量：封装一个可以改变的数据

        数组：封装一组数据

        方法：封装一段代码

        类：封装多个属性和方法

        Java文件：封装一个或多个类

        包：封装多个文件夹

        项目：封装多个包

包：

        本质:一个文件夹
        创建包:
                选择src文件夹,点击鼠标右键,选择new,选择package填写包名
        注意:
                包名使用全小写,不要用数组开头,不要出现特殊符号
        包名的命名潜规则:
                com.公司名称缩写.作用
        注意:.表示下一层文件夹

        关键字:package

导包:
        关键字:import
        为什么要导包:
                所需使用的类与当前类不在同一个包中

访问权限修饰符：

        意思：限制属性，方法，构造函数，类等的使用范围

        分类：

                关键字        意义           使用范围

                public        公共的        当前项目中

                protected   受保护的    当前包中活继承关系中

                不写           默认的        当前包中

                private        私有的        当前类中
总结：

        一般情况下：

                属性用private修饰，方法与类用public修饰

                属性用private修饰后需提供get与set方法

 继承

 概念：

        生活中的继承：晚辈获取长辈留下的财产与精神

        Java中继承：

                多个类（B1，B2）抽取其共同特点形成一个类（A）

                判断类A是否与类B有继承关系

                如果类A与类B有继承关系，让类B继承类A，此时类B可以继承类A所有属性和方法

                类A：称为类B的父类

                类B：称为类A的子类

优点：

        1.减少代码

        2.使代码结构清晰

        3.减低代码冗余度

super的使用：

        1.调用父类的构造函数：

                super（实参列表）；

                注意：

                        1.要在子类构函数的第一行；

                        2.子类函数如果没有调用父类函数的构造函数，会默认在其第一行有super，调用父类的无参构造函数，

        2.子类属性名和父类属性名重复时，用super来区分是子类属性还是父类属性，super.属性名表示父类属性

        3.子类与父类方法:

                要求:

                        在继承关系中

                        方法名相同

                        形参列表相同

                        返回值相同

                        子类访问权限修饰符比父类只可增大,不能减小

                        方法体不同

                这种方法称为重写,在有重写的情况下,用于区分子类方法还是父类方法,super.方法名

总结:

        子类将拥有父类的所有属性和方法,构造方法除外.

语法:

        访问权限修饰符 class 子类名 extends 父类名{

                属性

                构造方法

                方法        

        }

注意:

        一个子类只能有一个直接父类(继承)

        Java最终基类是object,如果一个类没有写继承,默认继承object

多态

概念:

        一个事物的多种形态

代码中的多态:

        事       

                方法重写与重载

         物(对象)

                如类A继承类B

                        类A:子类

                        类B:父类

                类名 A   对象名A = new 类名A();

                类名 B   对象B   =  对象A ; //子类转父类,可以直接转换(小类型转大类型)

                类名 A   对象A2 =  (类名A)对象B;  //父类对象转换子类对象,需强制转换,有风险

重写:
    要求:
        1,继承关系中
        2,访问权限修饰符:子类只能比父类大或不变
        3,返回值类型:相同
        4,方法名:相同
        5,形参列表:相同
        6,方法体:不同
重载:
    要求:
        1,同一个类中
        2,访问权限修饰符:不管
        3,返回值类型:不管
        4,方法名:相同
        5,形参列表:不相同
        6,方法体:不同

 三大修饰符

1.抽象的

概念：

        无法描述的，无法实例的

关键字：

        abstract

可以修饰：

        方法：

                格式：

                        访问权限修饰符 abstract 返回值类型 方法名（形参列表）；

                注意：

                        1.抽象方法没有方法体

                        2.有抽象方法的一定是抽象类

        类:

                语法格式:

                        访问权限修饰符 abstr class  类名{

                                属性

                               构造方法

                                方法

                        }

                注意:

                        1.子类继承于抽象类,要么重写抽象方法,要么自己也成为抽象类

                        2.抽象类无法创建对象

                        3.抽象类中不一定有抽象方法

 2.最终的

概念:

        不可修改的,最后的

关键字:

           final

修饰:

        类:

                意义:最终类,不能被继承的类

                语法:

                        访问权限修饰符 final class 类名 extends 父类名{

                                属性

                                构造方法

                                方法

                          }

        方法:

                意义:不可被重写

                语法:

                访问权限修饰符 final 返回值 方法名(形参列表){

                                方法体

                                return xx;

                        }

        属性:

                意思:不可被修改,称为常量,常量命名全大写

                语法:

                        访问权限修饰符 final 数据类型 属性名

                 fianl修饰的变量就是常量

        局部变量:

                意思:不可被修改,称为常量,常量命名全用大写

                语法:

                        final 数据类型 变量名

                final修饰的变量就是常量

3.静态的

概念:

        该类所有对象共有,属于类

关键字:

        static

修饰:

        属性:

                语法:

                        访问权限修饰符 static 数据类型 属性名;

                static所修饰的称为静态变量

                注意:

                        1.static所修饰的属性称为静态变量,属于类,一个对象进行修改,所有对象的该属性都进行改变

                        2.static修饰的属性多了一种调用方式:

                                语法:

                                        类名.属性

                                        类名.属性=值;(因为static修饰的属性属于类,所以可以直接用类调用)

                                原来:

                                        对象名.属性

                                        对象名.属性=值;

        方法:

                语法:

                        访问权限修饰符 static 数据类型 方法名(形参列表){

                                        方法体;

                                        return xx;

                                }

                static修饰的方法属于静态方法,

                注意:

                        1.静态方法只能使用静态成员(静态属性,静态方法)

                        2.static修饰的方法多了一种调用:

                                语法:

                                        类名.方法名(实参列表)

                                原来:

                                        对象名.方法名(实参列表)

                        3.静态方法中不能使用this和super

                                原因:

                                        当一个方法和属性被static属性修饰时，这些方法和属性是优先于对象加载进入内存的，是随着类的加载而加载的,this关键字是当前对象的引用，super是指父类的引用,当静态方法加载进内存进栈时，如果在静态方法中有this 和 super 关键字时，this和super也被加载到了内存，但是这个时候并没有对象的引用，this和super没有初始化，所有编译会报错。

   

        代码块:

                静态代码块

代码块

概念:

        一块代码

语法:

        {

                代码;

        }

调用:

        每次调用该类函数构造对象时,系统调用该类的普通代码块,在执行构造函数前执行

位置:

        类中方法外

与static结合使用

语法:        

        static{

       

         }

调用:

        类加载时调用,只会调用一次

        类的加载时机:

                                第一种情况:第一次创建该对象时

                                第二种情况 :第一次创建子类对象时

                                第三种情况:使用类名调用本类静态属性

                                第四种情况:使用类名调用本类静态方法

                                第五种情况:使用第一次使用反射获取该类对象时

                                                Class.forName("包名.类名");

                        注意:类只加载一次

        一个静态类和非静态类,先加载静态类

        在继承关系:先加载父类静态,在加载子类静态,父类非静态,子类非静态