Java_面向对象

面向对象

       面向对象是相对于面向过程的一种编程思想,它是基于面向过程的。

           面向过程:侧重于完成功能的过程。

           面向对象:侧重于完成功能的结果,强调的是对象。

 

        三个思想特点:

              a:更符合人思考习惯的一种思想。

              b:把复杂的事情简单化。

              c:把程序员从执行者变成指挥者。

 

类与对象

      编程语言都是为了把现实世界的事物给体现出来的,所以编程语言就应该和现实世界的事物对应。

        现实的事物分为两种:

               内在的特征:对应类的成员变量。

               外在的行为:对应类的成员方法。

      类:

          是一组相关的属性和行为的抽象。

          类的组成:

                 成员变量:名词

                        来自于现实世界的中的属性的一种抽象描述。

                 构造方法:

                        用于创建对象,对对象进行初始化

                        特点:

                              a :方法名于类名相同。

                        b:方法没有返回值类型。

                        c:方法没有返回值。

                  注意:

                        a:系统默认给出一个无参构造方法。

                        b:自己给出构造方法,系统将不在提供。

                        c:可以通过构造方法,给成员变量赋值。

                 成员方法:名词+动词    

                   完成一些功能。       

     对象:

         对象是类事物的具体的个体,也被称为实例。

         首先把事物的特征和行为体现出来,把事物转换成Java中的类,最后创建对象调用。

            应用场景:

                   创建对象:类名 变量名 = new 类名();

                   调用对象:对象名.方法();    对象名.变量;

           匿名对象:

                  没有名字的对象。

                  应用场景:

                          a:调用方法只用一次的时候(可提升效率)。

                          b:作为实际参数传递。

      局部变量与成员变量的区别:

            在类中的位置:

                       成员变量:在类中,方法外。

                       局部变量:在类的方法中。

          在内存中的位置:

                  成员变量:在堆中。heap

                  局部变量:在栈中。stack

          生命周期:

                  成员变量:随着对象创建而存在,随着对象消失而消失。

                  局部变量:随着方法调用存在,随着方法调用完毕而消失。

          初始化值:

                  成员变量:有默认初始值。

                      基本数据类型:

                           整型:0

                           浮点:0.0

                           char:’\u0000’

                      引用类型:null

                  局部变量:必须先声明,再赋值,最后才能被使用。

             

面向对象三大

      1,封装

             隐藏实现的细节,仅对外提供公共的访问方式。

                  体现形式:

                        a:类

                        b:方法

                        c:被private修饰也是封装的体现。

      2,继承

             在已知类的基础上扩充新的内容。

             extends表示继承的关系。class B extends A{}

             父类的定义:

                  是多个类中相同的成员变量和成员方法抽取出来的。

                  特点:

                              a:java中只能单继承。

                              b:java中可以多层继承(体系)。

                      优点:

                              a:提高了代码的复用性。

                              b:让类与类产生了联系,是多态的前提。

                      应用场景:

                              a:继承表达的是一种关系:is  a 。

                              b:不要为了部分功能而去继承。

                     继承后父子之间的成员关系:

                             成员变量:

                                    a:如果名字不同,直接调用本类的。

                                    b:如果名字相同的变量,在方法中使用的时候:

                                               先在局部范围查找,有就使用,

                                               然后成员位置查找,有就使用,

                                               最后在父类成员查找,有就使用,

                                               再没有就报错。

                             构造方法:

                                   a:子类并没有继承父类的构造方法。

                                   b:子类的构造方法执行前,会先执行父类的构造方法。这个时候,并没有创建父类对象,仅仅是对父类的内容进行了初始化。

                                         注意:如果在父类中没有无参构造,在子类中要么用this(…),要么用super(…) 。

                             成员方法:

                                  a:如果名字不同,直接调用本类的。

                                  b:如果有名字相同的方法,是重写的形式(覆盖、复写)。子类使用的是自己的方法,覆盖父类的方法。

                   方法重写:

                              override,子类与父类方法声明相同。 

                              体现形式:

                                   a:方法名相同,参数列表相同。

                                   b:子类返回值类型小于等于父类返回值类型。

                                   c:子类访问权限修饰符大于等于父类访问权限修饰符。

                              注意:

                                   a:父类的私用方法不能被重写。

                                   b:静态方法只能被静态方法重写。

                  方法重载:

                         overload,方法名相同,参数列表不同。

                         体现形式:

                                  a:方法名,参数列表不同。

                                  b:与返回值类型无关。

                                  c:与返回值无关。

                  this与super的区别:

                        this:代表当前类的对象,谁调用,就代表谁。

                        super:代表父类存储空间标识,父类的引用。

                        应用场景:

                              一般都在子类使用。

                              成员变量:

                                      this.变量

                                      super.变量

                              构造方法:

                                     this.(…)

                                     super.(…)

                              成员方法:

                                     this.方法()

                                     super.方法()

                           类的初始化:

                                         Person p=new Person();    

                                              a:把Person.class类加载到内存。

                                              b:执行该类中的静态代码块,如果有,给Person.class进化初始化。

                                              c:在栈内开辟存储变量p的空间,分配内存地址。

                                              d:在堆内开辟new Person()的空间。

                                              e:对成员变量进行默认初始化。

                                              f:对成员变量进行显示初始化。

                                              g:如果有构造代码块,通过它对成员变量进行初始化。

                                              h:通过构造方法对成员变量初始化。   

                                              i:对象创建完毕,把堆内存的地址值赋给栈内存中的变量p。

                       

      3,多态

             同一个对象在不同的时刻表现出不同的状态,编译期类型与运行期类型不一致。

             根据实际的对象不同而表现出的不同状态。

                  前提:

                        a:有继承或实现关系。

                        b:有method override。

                        c:有父类或父接口引用指向子类对象。

                  弊端:

                       不能使用子类特有的功能。

                  优点:

                       提高了程序的扩展性与维护性(由继承来保证)。

                 向上转型:

                       把子类对象赋值给父类对象或父接口引用。

                 向下转型:

                       把父类或父接口引用强制转换为子类

                 体现形式:

                      a:具体类多态

                      b:抽象类多态

                      c:接口多态

 

抽象类

       多个具体的事物具备相同的方法声明,而方法体不同,抽取方法声明,定义到一个类中。

       一个没有方法体的方法是一个抽象方法,一个类有抽象方法,该类必须定义为抽象类。

            特点:

                a:抽象类或抽象方法被abstract修饰。

                b:抽象方法没有方法体,抽象类中不一定有抽象方法,而有抽象方法一定是抽象类。而没有抽象方法的抽象类是为了不让外界创建对象。

                c:抽象类不能被实例化。构造方法主要用于对子访问父类数据的初始化。

                d:子类继承抽象类,要么是子类也是抽象类,要么重写父类所有抽象方法。

            抽象类的成员:

                   成员变量:有变量,也有常量。

                   构造方法:有构造方法,用于子类访问父类数据的初始化。

                   成员方法:有抽象方法,也有非抽象方法。

            注意:

                   抽象类不能与以下几个关键字共存。

                 a:final,final修饰的方法不能被重写,而abstract修饰的方法必须被重写,冲突。

                 b:private,private修饰的方法不能被重写,而abstract修饰的方法必须被重写,冲突。

                 c:static,static修饰的方法可以直接通过类名调用,而abstract修饰的方法,没有方法体,调用没有意义。

          实现继承:

                    分析:从具体到抽象。

                    实现:从抽象到具体。

                  

                    学习:抽象的内容,因为它定义的是共性的内容。

                    使用:具体的内容,因为它才是具体的实现,才能实现更多的功能。

接口

       当一个类中的方法都是抽象的时候,Java推荐了一种更抽象的方式,叫接口。

       特点:

                 a:接口用interface修饰。

                 b:子类实现接口用implements标识。

                 c:接口不能被实例化。

                 d:子类实现接口的时候,要么子类也是抽象类,要么全部实现接口的方法。

       思想特点:

                 a:对外暴露的规则。

                 b:程序的扩展功能。(多态)

                 c:降低程序的耦合性。(多态)

                          高内聚

                          低耦合

                          效率与安全

                 d:让类可以多实现。    

       成员特点:

               成员变量: 是常量,默认修饰符:public static final

               成员方法:是抽象方法,默认修饰符:public abstract

       接口和抽象类的区别:

               共性:都是不断抽取出来抽象的内容。

                     成员特点:

                                 抽象类:

                                           成员变量:可以是常量,可以是变量。

                                           构造方法:有。

                                           成员方法:可以是抽象方法,也可以是非抽象方法。

                                 接口:

                                           成员变量:只能是常量。

                                           成员方法:只能是抽象方法。

                                           无构造方法。

                    继承和实现关系:

                               a:类与类的关系:

                                           继承关系,只能单继承,可以多层继承。

                               b:类与接口的关系:

                                           实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口。

                               c:接口与接口的关系:

                                           继承关系,可以单继承,也可以多继承。

                    设计区别:

                                抽象类中定义的体系是共性,表达的是:is a的关系。

                                接口定义的体系是扩展性,表达的是:like a 的关系。

内部类

          把类定义在一个类的内部。

          特点:

                内部类可以直接使用外部类,包括私有。

                外部类要使用内部类,必须要创建对象调用。

           内部类分类:

                 成员内部类:定义在类中,方法外的内部类。

                                 private:为了数据安全。

                                 static:为了方便调用。

                 局部内部类:定义在方法中的内部部类。

          匿名内部类

                      a:没有名字的内部类。其本质是一个对象。

                      b:前提,存在一个抽象类或者接口。

                      c:格式:

                                   new 抽象类名或接口(){

                                           重写父类方法;

                                   };

               本质:是一个继承了类或者实现接口的子类匿名对象。

 

关键字

        private:

              私有的意思,可以修饰成员变量、构造方法、成员方法。

              被private修饰的成员只能在本类中访问。

              怎么赋值给被private修饰的成员:

                          a:同过setXxx()和getXxx()方法。

                          b:通过构造方法

        this:

              代表当前类的对象,谁调用,就代表谁。

              应用场景:

                  a:解决局部变量隐藏成员变量。

                  b:在本类的构造方法中调用本类的构造方法(只能放在第一条语句)。

        super:代表父类空间存储标识,可以理解为对父类引用。

        final:

              最终的意思,它可以修饰类,成员方法,变量。

              特点:

                   它修饰的类不能被继承。

                   它修饰的成员方法不能被重写。

                   它修饰的变量是常量。

            注意:

                final修饰的基本数据类型的值不能被改变。

                final修饰的引用类型,地址值不能改变,对象内容可以改变。

        abstract:抽象的意思,可以修饰成员方法和类。

        interface:接口的意思。

        extends:继承的关键字,让类与类之间产生了联系,是多态的前提 。

        implements:实现接口的关键字。

        static:

             表示静态的意思。

             可以修饰成员变量和方法。

             特点:

                  a:随着类的加载而加载。

                  b:优先于对象而存在。

                  c:被所有对象共享。

                  d:可以直接通过类名直接调用。

                       静态修饰的内容,即可以通过类名调用,也可以通过对象调用。

             注意:

                  a:静态只能访问静态。 因为静态方法和变量在类加载时就存在,非静态变量在对象存在时才存在。

                  b:随着类加载而存在,生命周期长,占用资源,效率低。

                  c:静态方法中不可定义this,super关键字。因为静态优先于对象存在,所以静态方法不可以出现this。

             应用场景:

                  a:被所有对象访问的数据。节省空间,没必要为每个对象单独存储。

                  b:工具类,方便直接通过类名调用。

            main方法的解释 :

                public static void main(String [] args)

                  public:公共的,足够的访问权限。

                  static:静态的,为了不创建对象,直接调用。

                  void:返回給JVM没有意义。

                  main:主方法,程序入口,是标准规范。

                  String [] args:早期为了接收键盘数据,现在被Scanner替代。

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

                  a:在类中的初始化值的过程是一样的。

                  b:在内存中的位置:

                        成员变量:在堆中。

                        静态成员变量:在方法区的静态区。

                  c:生命周期:

                        成员变量:随着对象的创建而存在,随着对象的消失而消失。

                        静态成员变量:随着类的加载而存在,随着类的消失而消失。

                  d:设计和调用的区别:

                        设计:

                            成员变量:每个对象是独立的特征。

                            静态成员变量:所有对象是共享的特征。

                        调用:

                            成员变量:只能通过对象调用。

                            静态成员变量:可以通过类名直接调用,也可以通过对象调用。

 

权限修饰符

 

                             本类                同一包下            不同包下的子类             不同包下的无关类

private                     y

default                     y                      y                           

protected                 y                      y                          y

public                       y                      y                          y                                       y

 


  权限修饰符的组合以及常见使用

                               类                  成员变量               构造方法                         成员方法        

private                                              y                           y                                     y

default                     y                       y                           y                                     y

protected                                         y                           y                                     y

public                       y                      y                           y                                     y

abstract                   y                                                                                          y

final                         y                       y                                                                 y

static                                                y                                                                 y

 

 

你可能感兴趣的:(java)