面向对象

Posted ljlaction

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象相关的知识,希望对你有一定的参考价值。

十四、代码块

  静态代码块

    随着类的加载而执行,只会执行一次

  构造代码块

    每次创建对象都会执行,用于初始化所有构造方法都必须初始化的数据

  局部代码块

    局部代码块执行完之后会被立马认为是垃圾

  静态代码块,构造代码块,构造方法的执行顺序   

    静态代码块 - >构造代码块 -> 构造方法

十五、继承

  概述

    多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承这个新定义的类即可。
   通过extends关键字可以实现类与类的继承
   被继承的这个类称为父类,基类或者超类
   继承的类可以称为子类或者派生类。
   有了继承以后,我们定义一个类的时候,可以在一个已经存在的类的基础上,还可以定义自己的新成员。

  格式

    class 子类名 extends 父类名 {}

  优点

     提高了代码的复用性
    多个类相同的成员可以放到同一个类中
    提高了代码的维护性
    如果功能的代码需要修改,修改一处即可
    让类与类之间产生了关系,是多态的前提
    其实这也是继承的一个弊端:类的耦合性很强

  特点

     Java只支持单继承,不支持多继承。
    一个类只能有一个父类,不可以有多个父类。
    class SubDemo extends Demo{} //ok
    class SubDemo2 extends Demo1,Demo2...//error
    Java支持多层继承(继承体系)
    class A{}
    class B extends A{}
    class C extends B{}

  注意事项

     子类只能继承父类所有非私有的成员
    子类不能继承父类的构造方法,但是可以通过super()关键字去访问父类构造方法。
    不要为了部分功能而去继承

  继承中成员变量的关系

     在子类方法中访问一个变量
    首先在子类局部范围找
    然后在子类成员范围找
    最后在父类成员范围找
    如果还是没有就报错。

  super关键字

     super的用法和this很像
      this代表本类对应的引用。
      super代表父类存储空间的标识(可以理解为父类引用)
    用法(this和super均可如下使用)
      访问成员变量
        this.成员变量 super.成员变量
      访问构造方法(子父类的构造方法问题讲)
        this(…) super(…)
      访问成员方法(子父类的成员方法问题讲)
        this.成员方法() super.成员方法()

  继承中构造方法的关系

     子类中所有的构造方法默认都会访问父类中空参数的构造方法
    因为子类会继承父类中的数据,可能还会使用父类的数据。所以,子类初始化之前,一定要先完成父类数据的初始化。
    每一个构造方法的第一条语句默认都是:super()

    如果父类中没有默认空参构造方法,子类通过super去显示调用父类其他的带参的构造方法
    子类通过this去调用本类的其他构造方法
    本类其他构造也必须首先访问了父类构造
    一定要注意:
      super(…)或者this(….)必须出现在第一条语句上

  继承中成员方法的关系

    通过子类对象去访问一个方法
      首先在子类中找
      然后在父类中找
      如果还是没有就报错。

  继承中成员方法重写

    方法重写概述
      子类中出现了和父类中一模一样的,也被称为方法覆盖,方法复写。
    使用特点:
      如果方法名不同,就调用对应的方法
      如果方法名相同,最终使用的是子类自己的
    方法重写的应用:
      当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。

  继承中成员方法重写注意事项

    父类中私有方法不能被重写
    子类重写父类方法时,访问权限不能更低
    父类静态方法,子类也必须通过静态方法进行重写。(没有方法重写的特性,多态中证明)

  final关键字

    final关键字是最终的意思,可以修饰类,成员变量,成员方法。
    修饰类,类不能被继承
    修饰变量,变量就变成了常量,只能被赋值一次
    修饰方法,方法不能被重写

  单例设计模式

    1、饿汉式:在程序启动或单件模式类被加载的时候,单件模式实例就已经被创建。

      public Simple(){
        private static Single s=new Single();
        private Single(){

        }
        public static Simple getSimple(){
        return s;
        }
      }


    2、懒汉式:当程序第一次访问单件模式实例时才进行创建。

      class Single{
        private static Single s = null;

        public Single() {
        if (s == null)
          s = new Single();
          return s;
         }
       }

十六、多态

  概述

    某一个事物,在不同环境下表现出来的不同状态。

  多态前提和体现

    有继承关系
    有方法重写
    有父类引用指向子类对象

  成员访问特点

    成员变量
      编译看左边,运行看左边
    成员方法
      编译看左边,运行看右边
    静态方法
      编译看左边,运行看左边
    所以静态方法不能算方法的重写

  多态的好处

    提高了程序的维护性(由继承保证)
    提高了程序的扩展性(由多态保证)

  多态的弊端

    不能访问子类特有功能

  向上转型

    从子到父
    父类引用指向子类对象

  向下转型

    从父到子
    父类引用转为子类对象

十七、抽象类

  抽象类和抽象方法必须用abstract关键字修饰

  格式:

    abstract class 类名 {}
    public abstract void eat();

  抽象类的成员特点

    成员变量
      可以是变量
      也可以是常量
    构造方法
      有构造方法,但是不能实例化
    构造方法的作用
      用于子类访问父类数据的初始化
    成员方法
      可以有抽象方法 限定子类必须完成某些动作
      也可以有非抽象方法 提高代码复用性

  抽象类特点

    抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
    抽象类不能实例化
    按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
    抽象类的子类
    要么是抽象类
    要么重写抽象类中的所有抽象方法

十八、接口

  接口用关键字interface表示

  格式:

    interface 接口名 {}

  接口成员特点

    成员变量
      只能是常量
      默认修饰符 public static final
    构造方法
      没有,因为接口主要是扩展功能的,而没有具体存在
    成员方法
      只能是抽象方法
      默认修饰符 public abstract

  接口特点

    接口不能实例化
    按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态。
    类实现接口用implements表示
    格式:class 类名 implements 接口名 {}
    接口的子类
    要么是抽象类
    要么重写接口中的所有抽象方法

  类和接口以及彼此之间的关系

    类与类
      继承关系,只能单继承,但是可以多层继承
    类与接口
      实现关系,可以单实现,也可以多实现。还可以在继承一个类的同时实现多个接口
    接口与接口
      继承关系,可以单继承,也可以多继承

  抽象类和接口的区别

    成员区别
      抽象类 变量,常量; 抽象方法;抽象方法,非抽象方法
      接口 常量;抽象方法
    关系区别
      一个类只能继承一个抽象类
      一个类可以实现多个接口
    设计理念区别
      抽象类 共性功能
      接口 扩展功能

  总结:

    1.一个类可以实现多个接口,但却只能继承最多一个抽象类。
    2.抽象类可以包含具体的方法,接口的所有方法都是抽象的。
    3.抽象类可以声明和使用字段,接口则不能,但接口可以创建静态的final常量。
    4.接口的方法都是public的,抽象类的方法可以是public,protected,private或者默认的default;
    5.抽象类可以定义构造函数,接口却不能。

十九、包

  概述:

    其实就是文件夹

  作用:

    对类进行分类管理

  包的划分:

    不同的包,装不同功能的类

  包的定义格式和注意事项

    定义包的格式
      package 包名;
      多级包用.分开即可
    注意事项:
      package语句必须是程序的第一条可执行的代码
      package语句在一个java文件中只能有一个
      如果没有package,默认表示无包名

  带包的类的编译和运行

    手动式

      javac编译当前类文件。
      手动建立包对应的文件夹。
      把a步骤的class文件放到b步骤的最终文件夹下。
      通过java命令执行。注意了:需要带包名称的执行
      java 包名.类名

    自动式

        javac编译的时候带上-d即可
        javac -d . 源文件名.java
        通过java命令执行。和手动式一样
        java 包名.类名

  导包概述

    不同包下的类之间的访问,我们发现,每次使用不同包下的类的时候,都需要加包的全路径。比较麻烦。这个时候,java就提供了导包的功能。

  导包格式

    import 包名;
    注意:
      这种方式导入的是到类的名称。

  权限修饰符

          技术分享图片

二十、内部类

  概述

    把类定义在其他类的内部,这个类就被称为内部类。
    举例:在类A中定义了一个类B,类B就是内部类。
    内部类的访问特点:
      内部类可以直接访问外部类的成员,包括私有。
      外部类要访问内部类的成员,必须创建对象。

  内部类分类

    按照内部类在类中定义的位置不同,可以分为如下两种格式:
    成员位置(成员内部类)
    局部位置(局部内部类)

  访问成员内部类里面的成员

    成员内部类的常见修饰符
      private 为了保证数据的安全性
      static 为了让数据访问更方便
    外界访问内部类非静态成员
      外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
      对象名.成员;
    外界访问静态内部类非静态成员
      外部类名.内部类名 对象名 = new 外部类名.内部类名();
      对象名.成员;
    外部访问静态内部类静态成员
      外部类名.内部类名 对象名 = new 外部类名.内部类名();
      对象名.成员;
        或
      外部类名.内部类名.成员;

  局部内部类

    可以直接访问外部类的成员
    可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能

  类和其组成可以用的修饰符

    外部类:
      public,默认修饰符,final,abstract
      我们自己定义:public居多
    成员变量和成员内部类:
      四种权限修饰符,final,static
      我们自己定义:private居多
    局部变量和局部内部类
      final
    构造方法:
      四种权限修饰符
      我们自己定义:public 居多
    成员方法:
      四种权限修饰符,final,static,abstract
      我们自己定义:public居多

  匿名内部类

    就是内部类的简化写法。
    前提:存在一个类或者接口
    这里的类可以是具体类也可以是抽象类。
    格式:
      new 类名或者接口名() {重写方法;}
    本质:
      是一个继承了类或者实现了接口的子类匿名对象

















































































































































































以上是关于面向对象的主要内容,如果未能解决你的问题,请参考以下文章

224 面向对象编程介绍,面向过程与面向对象

面向对象-面向对象和面向过程的区别

面向对象分析与设计面向对象设计包括哪些内容

面向对象

面向过程面向对象及面向对象的三大特征

Python面向对象学习 1 (什么是面向对象,面向对象的应用场景)