02 面向对象与内存管理

1. 成员内部类：

• 类中套类，外面的称为外部类，里面的称为内部类，内部类只能服务于外部类，对外不具备可见性。
• 内部类对象也是需要在外部类中创建，内部类中可以直接访问外部类的成员，包括私有的，因为在内部类有个隐式的引用指向了创建它的外部类对象------外部类名.this。

2. 匿名内部类：

• 若想创建一个类(派生类)的对象，并且对象只被创建一次，此时可以设计为匿名内部类。
• 匿名内部类中不能修改外面局部变量的值，因为该值在此处默认为final的。

3. 接口：

• 是一种引用数据类型

• 由interface定义

• 只能包含常量和抽象方法

• 接口中的数据默认都是常量，方法默认都是抽象的

• 接口中成员的访问权限，默认就是public的，也只能是public的

• 不能被实例化

• 接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法

• 一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现

• 接口可以继承接口

  /** 接口的演示 */
  public class InterfaceDemo {
      public static void main(String[] args) {
          //Inter5 o1 = new Inter5(); //编译错误，接口不能被实例化
          Inter5 o2 = new Doo(); //向上造型
          Inter4 o3 = new Doo(); //向上造型
      }
  }
  
  //演示接口继承接口
  interface Inter4{
      void show();
  }
  interface Inter5 extends Inter4{
      void test();
  }
  class Doo implements Inter5{
      public void test(){}
      public void show(){}
  }
  
  //演示接口的多实现
  interface Inter2{
      void show();
  }
  interface Inter3{
      void test();
  }
  abstract class Boo{
      abstract void say();
  }
  class Coo extends Boo implements Inter2,Inter3{
      public void show(){}
      public void test(){}
      void say(){}
  }
  
  //演示接口的实现
  interface Inter1{
      void show(); //默认访问权限为public的
      void test();
  }
  class Aoo implements Inter1{
      public void show(){} //重写接口中的抽象方法时，必须加public权限
      public void test(){}
  }
  
  //演示接口的语法
  interface Inter{
      //接口中成员的访问权限，默认就是public的，也只能是public的
      public static final int NUM = 5;
      public abstract void show();
      int COUNT = 5; //默认public static final
      void test(); //默认public abstract
      //int number; //编译错误，常量必须声明同时初始化
      //void say(){ } //编译错误，抽象方法不能有方法体
  }
  

4.多态：

• 意义：

  • 同一个对象被造型为不同的类型时，有不同的功能------所有对象都是多态的

    ----对象多态：我、你、水…

  • 同一类型的引用指向不同的对象时，有不同的实现------所有抽象方法都是多态的

    ----行为多态：cut()、getImage()、move()、getScore()…

• 向上造型/自动类型转换：

  • 超类型的引用指向派生类的对象(前面是超类型，后面是派生类型)
  • 能点出来什么，看引用的类型(这是规定)
  • 能向上造型成为的类型有：超类+所实现的接口

• 强制类型转换，成功的条件只有如下两种：

  • 引用所指向的对象，就是该类型
  • 引用所指向的对象，实现了该接口或继承了该类

• 强转若不符合如上条件，则发生ClassCastException类型转换异常

  建议：在强转之前一定要先通过instanceof来判断引用的对象是否是该类型

  强转时若符合如上的两个条件，则instanceof返回true，若不符合则返回false

  何时需要强转：你想访问的东西在超类中没有，那就需要强转

  public class MultiType {
      public static void main(String[] args) {
          //条件1:引用所指向的对象，就是该类型
          //条件2:引用所指向的对象，实现了该接口或继承了该类
          Aoo o = new Boo(); //向上造型
          Boo o1 = (Boo)o;     //引用o所指向的对象，就是Boo类型-------符合条件1
          Inter o2 = (Inter)o; //引用o所指向的对象，实现了Inter接口---符合条件2
          //Coo o3 = (Coo)o; //运行时会发生ClassCastException类型转换异常
  
          //判断o是否是Coo类型(与强转成功条件完全匹配)
          if(o instanceof Coo){ //false
              Coo o4 = (Coo)o; //instanceof若为true，则强转一定成功
          }else{
              System.out.println("o不是Coo类型");
          }
  
      }
  }
  interface Inter{  }
  class Aoo{  }
  class Boo extends Aoo implements Inter{  }
  class Coo extends Aoo{  }
  

5.内存管理：由JVM管理

• 堆：

  • 存储的是new出来的对象(包括实例变量、数组的元素)

  • 垃圾：没有任何引用所指向的对象

    垃圾回收器(GC)不定时到堆中清扫垃圾，回收过程是透明的(看不到的)，并不一定一发现垃圾就立刻回收，通过调用System.gc()建议虚拟机尽快调度GC来回收

  • 实例变量的生命周期：

    ​在创建时对象时存储在堆中，对象被回收时一并被回收

  • 内存泄漏：不再使用的对象还没有被及时的回收，严重的泄漏会导致系统的崩溃

    建议：不再使用的对象应及时将引用设置为null

• 栈：

  • 存储正在调用的方法中的局部变量(包括方法的参数)

  • 调用方法时会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除

  • 局部变量的生命周期：

    ​ 调用方法时存储在栈中，方法调用结束时与栈帧一并被清除

• 方法区：

  • 存储.class字节码文件(包括静态变量、所有方法)
  • 方法只有一份，通过this来区分具体的调用对象

• 字符串(String)常量池：

  • java.lang.String使用final修饰，不能被继承

  • String的底层封装的是一个字符数组

  • String在内存中采用Unicode编码格式，每个字符占用两个字节的空间

  • 字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值(指向新的对象)

    --------不变对象

  • java对String字符串有一个优化措施：字符串常量池(堆中)

  • java推荐我们使用字面量/直接量的方式来创建对象，并且会缓存所有以字面量形式创建的字符串对象到常量池中，当使用相同字面量再创建对象时将会复用常量池中的对象，以减少内存开销。

    注意：只有使用字面量方式创建的对象，才会存储在字符串常量池中