内部类

什么是内部类?

---

内部类 : 在一个类中定义的另外一个类.

内部类的优势

为什么要使用内部类?

1. 内部类拥有外围类所有元素的访问权限

2. 内部类可以很好的实现隐藏(可以使用 private 和protected修饰)

3. 可以让一个类实现多重继承

4. 避免修改接口而实现一个类中两种同名方法调用

案例 1

//定义一个外围类
public class DefineInnerClass {
    //定义外围类的属性
    private String name;
    private int age;
 //实现外围类的Get Set方法
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 
 //内部类
 class InnerClass{
  public InnerClass(){
   name = "蓝桥";
   age = 18;
  }
  public void dispaly(){
   System.out.println("name: "+getName()+"=====age: "+getAge());
  }
 }
}
​
//定义主函数
public class TestMain(){
 //实例化BaseInnerClass
 BaseInnerClass baseInnerClass = new BaseInnerClass();
 //创建内部类
 BaseInnerClass.InnerClass innerClass = baseInnerClass.new InnerClass();
 innerClass.dispaly();
}

总结 : 1. 内部类可以对外围类的属性访问. <font color=blue>解析 : 当外部类对象创建了一个内部类的对象时候,内部类对象会捕获一个指向外部类 对象的引用,然后访问外部类的成员时,就用那个引用来选择外围类的成员.编译器自动帮我们处理.
2. 引用内部类的需要指明这个对象的类型.
3. 创建内部类对象必须要利用外部类的对象.
4. 内部类是编译期的概念,编译完成就是两个独立的类.
5. 推荐使用get方法获取内部类.
</font>

案例 2

//定义接口
public interface InterfaceHide{
    void increment();
}
​
//定义实现类
public class HideRealize {
 //定义内部类
 private class InnerClass implements InterfaceHide{
  @Override
  public void increment() {
   System.out.println("你的财产已经别我承包了~");
  }
 }
 public InterfaceHide getInt(){
  return new InnerClass();
 }
}
​
//主函数
public class HideMain {
 public static void main(String[] args) {
  //创建外围类
  HideRealize hide = new HideRealize();
  //获取内部类
  InterfaceHide interfaceHide = hide.getInt();
  //调用实现接口方法
  interfaceHide.increment();
 }
}

总结 : 普通的类不能使用private,protected访问修饰符来修饰,而内部类可以.当我们使用private修饰内部类的时候就可以实现对外隐藏.比如内部类实现接口,向上转型对外来说,就完全隐藏了接口的实现.对于用户来说只需要调用一个方法就能帮助实现想要实现的复杂功能是最好不过了,多了反而会迷惑.把接口对外使用,实现对外隐藏.

案例 3

//定义第一个类
public class Chip {
    public String descChip(){
        return "高通骁龙 855";
 }
}
​
//定义第二个类
public class Memory {
 public int memorySize(){
  return 16;
 }
}
​
//定义子类
public class MobilePhone {
 //内部类1继承第一个类
 private class partOne extends Chip{
  @Override
  public String descChip() {
   return super.descChip();
  }
 }
 //内部类2继承第二个类
 private class partTwo extends Memory{
  @Override
  public int memorySize() {
   return super.memorySize();
  }
 }
 
 public String chip(){
  return new partOne().descChip();
 }
 
 public int memory(){
  return new partTwo().memorySize();
 }
}
​
//定义主函数
public class MainExtends {
 public static void main(String[] args) { 
  MobilePhone phone = new MobilePhone();
  System.out.println("手机芯片是:"+phone.chip());
  System.out.println("手机内存是:"+phone.memory()+"GB");
 }
}

总结 : 在Java中只能够继承一个类,如果没有内部类,只能通过去实现接口来实现.但是实现接口需要覆盖接口中所有的方法.外部类通过内部类拥有了其他类的继承关系,而且不必关心被继承类的具体方法实现.

案例 4

//定义父亲的爱
public class Father {
    public void love(){
        System.out.println("爸爸爱你❤");
 }
}
​
//定义母亲的爱
public interface Mother {
 //接口中的方法默认都是public、abstract类型的
 void love();
}
​
//主函数
//public class RepeateMain extends Father implements Mother{
// 
//这个方式是属于 Father里面的方法还是Mother里面的方法?
// public void love() {}
//}
public class RepeateMain extends Father{
 //Father的Love实现
 @Override
 public void love() {
  super.love();
 }
 
 private void moLove(){
  System.out.println("妈妈爱你❤");
 }
 
 //定义内部类实现接口
 private class MoLove implements Mother{
  //Mother的Love实现
  @Override
  public void love() {
   moLove();
  }
 }
 MoLove getRunning(){ 
  return new MoLove();
 }
}

总结 : 如果一个类要继承一个类,并且要实现一个借接口,如果这两个里面有一个相同的方法,可以使用内部类来实现接口,这样就不会与外围类的方法冲突.

内部类的分类

A. 静态内部类与非静态内部类

public class ClassOther {

 //外部类属性
 private String name = "lanqiao";
 private static int age = 18;
 
 //外部类方法
 public void run(){
  System.out.println("外部类方法 : 蓝桥老师在狂奔.............");
 }
 
 //非静态内部类
 public class InnerClass{
  //static int height = 174; 非静态内部类不能有静态成员
  public void run(){
   //非静态内部类可以访问外部类的变量
   System.out.println(name);
   System.out.println(age);
  } 
 }
 
 //静态内部类
 public static class StaticInnerClass{
  //静态内部类可以有静态成员
  static int number = 88888;
  public void run(){
   //静态内部类不可访问外部类的非静态变量
   //System.out.println(name);
   System.out.println(age);
  }
 }
 
 public static void main(String[] args) {
  //非静态内部类创建方式 一
  ClassOther.InnerClass innerClass = new ClassOther().new InnerClass();
  //非静态内部类创建方式 二
  ClassOther outher = new ClassOther();
  ClassOther.InnerClass inner = outher.new InnerClass();
  
  //静态内部类的创建不依赖与外部类,而非静态内部类必须依赖于外部类的创建而创建。
  //静态内部类的创建方式
  ClassOther.StaticInnerClass staticInnerClass = new ClassOther.StaticInnerClass();
 }

}

总结 : 1. 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 

2. 静态内部类可以访问外部类的静态变量，而不可访问外部类的非静态变量； 

3. 非静态内部类可以访问外部类的变量。 

4. 内部类是编译期的概念,编译完成就是两个独立的类. 5. 静态内部类的创建不依赖于外部类，而非静态内部类必须依赖于外部类的创建而创建。

B.局部内部类

public class ClassOuterOne {
 private String name = "lanqiao";
 private  int age = 18;
 
 public  void fun() {
  System.out.println("外部类方法>>>>>>");
 }
 
 public void functionClass(){
  class InnerClass{
   private void fun(){
    System.out.println("局部内部类输出>>>>>>>>");
    System.out.println(name);
    System.out.println(age);
   }
  }
  InnerClass innerClass = new InnerClass();
  innerClass.fun();
 }
}

总结 : 1. 局部内类不允许使用访问权限修饰符 public private protected 均不允许。 2. 局部内部类对外完全隐藏，除了创建这个类的方法可以访问它其他的地方是不允许访问的。 3. 主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的。 

C. 匿名内部类

public class Button {
 public void click(){
  //匿名内部类，实现的是ActionListener接口
  new ActionListener() { 
   @Override
   public void onAction() {
    System.out.println("谁点我..........");
   }
  }.onAction();
 }
 
 //匿名内部类必须继承或实现一个已有接口
 public interface ActionListener{
  public void onAction();
 }
 
 public static void main(String[] args) {
  Button button = new Button();
  button.click();
 }

}

总结 : 1. 匿名内部类是没有访问修饰符的。 

2. 匿名内部类必须继承一个抽象类或者实现一个接口。 

3. 匿名内部类是没有构造方法的，因为它没有类名的。 

转载于:https://www.cnblogs.com/LihanyangQAQ/p/11262104.html