面向对象笔记

DoraMike
225 阅读6分钟

面向对象的三大特性：

一、封装性

1. 成员变量和局部变量的区别

  1. 成员变量定义在类中，整个类的可以访问;局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。

  2. 成员变量存在于堆内存的对象中。局部变量存在于栈内存的方法中（局部代码块）。

  3. 成员变量随着对象的创建而存在，随着对象的消失而消失;局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

2、成员变量和静态变量的区别

  1. 生命周期不同，成员变量随着对象的创建而存在，随着对象的被回收而释放。静态变量随着类的加载而存在，随着类的消失而消失。
  2. 调用方式不同。成员变量只能被对象调用。静态变量可以用对象调用，还可以用类名调用。
  3. 数据的存储位置不同。成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。静态变量数据存储在方法区（的静态区），所以叫对象的共享数据。

3、构造函数

     作用：可以给对象初始化，创建对象的时候就调用了。

  1. 在类中如果定义了构造了，那么默认的构造函数就没有了

  2. 定义构造函数的原因，对象一产生就具有的内容。

  3. 可以定义私有化构造函数来阻止对象的创建。

4、关键字

  1. this哪个对象调用就代表哪个对象，把局部变量的值传递给成员变量。关键字this也可以用于在构造函数中调用其他构造函数，但对this的调用必须是构造函数的第一句。
  2. static的特点：
  • static修饰的成员被所有的对象所共享。
  • static优先于对象存在，static修饰的成员随着类的加载就已经存在了
  • 可以被类名直接调用
  1. 静态使用的注意事项：
  • 静态方法只能访问静态成员。
  • 静态方法不能使用this或者super关键字
  • 主函数是静态的

5、主函数

  • public：因为权限是最大的。
  • static：不需要对象，直接用主函数所属类名调用即可。
  • void：主函数没有具体的返回值。
  • main：函数名，不是关键字，只是一个jvm识别的固定名字
  • String[] args：这是主函数的参数列表，是一个数据类型的参数。
  • 格式固定。

6、单例设计模式

  • 一个类在内存里的对是唯一性的；

     //饿汉式
 class Single//类一加载，对象就存在了
 {
     private static Single s = new Single();
     private Single(){}
     public static Single getInstance()
     {
         return s;
     }
 }

 //懒汉式
 class Single2//类加载，没有对象，只有调用getInstance方法时，
 //才会创建对象。
 {
     private static Single2 s = null;
     private Single2(){}
     public static Single2 getInstance()
     {
         if(s==null)
     	    s = new Single2();
      return s;
     }
 }

二、继承

用extends修饰

1、继承的作用：

  1. 提高了代码的复用性。
  2. 让类与类之间产生关系，给多态提供了条件。
  3. 注意事项：Java支持单继承，不直接支持多继承。但Java支持多重继承。

   单继承：一个子类只能有一个直接父类。    多继承：一个子类可以有多个直接父类。

2、关键字

  1. this代表一个本类对象的引用，解决局部变量和成员变量名字相同的问题。
  2. super代表一个父类的空间，解决父类变量名字和子类变量名字相同的问题。
  3. final可以修饰类，方法，变量。final修饰的类不能继承，final修饰的方法不能被覆盖，final修饰的变量是常量

3、成员函数

  1. 当子父类函数一模一样的情况下，会运行子类的函数。这种现象称为覆盖，也就是重写。
  2. 覆盖注意事项：子类方法覆盖父类方法时候，子类权限必须大于或等于父类权限。
  3. 什么时候使用覆盖：当一个类进行子类扩展时，子类需保留父类的功能声明，但要定义子类中功能的特定内容时就要使用覆盖。对子类进行升级时，保留父类的内容时，可使用super.函数名（）;

4、构造函数

  1. 子类的实例化过程：子类中所有的构造函数都会默认调用父类的空参构造函数。
  2. 如果父类中没有空的构造函数，子类的构造函数中必须用super调用父类中的构造函数。
  3. super语句必须定义在第一行，父类的初始化必须先完成。
  4. 等super初始化完成后，才进行子类的成员变量显示初始化。

5、抽象类 abstract

  1. 类中有抽象方法的，类也要加 abstract 修饰。抽象类中可以同时存在抽象函数和非抽象函数。
  2. 抽象类不可以实例化。但有构造函数，给其子类初始化。
  3. 抽象类必须被子类覆盖所有的抽象方法后才可以实例化，不然子类还是抽象类。
  4. 抽象类可以没有抽象方法，通常为了不给类创建对象。
  5. 抽象关键字不能和private，static，final共存

6、接口 interface

  1. 用interface而不用class关键字。
  2. 接口中常见的成员，而且这些成员有固定的修饰符：
  • 全局变量：public static final
  • 抽象方法：public abstract
  1. 接口中的成员权限都是公共的，只能定义抽象方法。
  2. 实现接口 用implements ，例如class 类名 implements 接口名{}。
  3. 接口不可以实例化，实现了接口的子类需覆盖所有的抽象方法才能实例化，不然子类是抽象类。
  4. 一个类可以实现多个接口，解决了多继承的不确定性。
  5. 一个类在继承另一个类的同时，还能实现多个接口。
  6. 接口与接口之间是继承关系，还可以多继承。

三、多态

  1. 多态是指一个对象对应着不同的类型，代码中体现为父类或者接口的引用指向其子类对象。父类名 变量名1 = new 子类（）；但不能调用子类中特有的方法，可以用转型 子类 变量名2 = （子类名）变量名1； 实现
  2. instanceof：用于判断对象的具体类型。对象名 instanceof 类名。
  3. 成员的特点：
  • 成员变量：编译和运行都参考等号左边。
  • 成员函数：编译看左边，运行看右边。
  • 静态函数：编译和运行看左边，不涉及多态性，运行不需要对象。

四、内部类

把一个类定义在另一个类里面，里面那个类就叫做内部类。

  1. 访问特点：
  • 内部类可以直接访问外部类中的成员，等于是外部类的成员。
  • 外部类访问内部类需要创建对象
  1. 创建内部类对象时，外部类名.内部类名 变 = new 外名().new 内名();
  2. 内部类可用成员修饰符，如public，static....。
  3. 如内部类是静态的，外名.内名 变 = new 外名.内名（）；
  4. 如果内部类的成员是静态的，内部类也要是静态的。
  5. 内部类在局部位置上，只能访问局部中被final修饰的局部变量。
  6. 匿名内部类必须是继承外部类或实现接口的。
  7. 匿名内部类就是子类的对象，格式：new 父类或接口名（）{子类内容}；
avatar
文章
阅读
粉丝