Java学习笔记-13，内部类使用

内部类

非静态内部类

• 内部类可以直接访问外部类的成员（public，private，protectd）

• 不能用static修饰

• 先实new一个外部类，才能new一个内部类

• 内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符：

class OuterClass {
  int x = 10;

  class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}
//该例子来自菜鸟网站

静态内部类

• 静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它：

• 静态内部类无法访问外部类的成员。

class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}//该例子来自菜鸟网站

局部内部类

• 指的是定义在一个方法中的内部类
• 局部内部类与局部变量一样，不能使用访问控制修饰符，局部内部类与局部变量一样，不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰。
• 局部内部类只在当前方法中有效。
• 局部内部类中不能定义 static 成员。
• 局部内部类中还可以包含内部类，但是这些内部类也不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰。
• 在局部内部类中可以访问外部类的所有成员。
• 在局部内部类中只可以访问当前方法中 final 类型的参数与变量。如果方法中的成员与外部类中的成员同名，则可以使用 .this. 的形式访问外部类中的成员。

public class Test {
    int a = 0;
    int d = 0;
    public void method() {
        int b = 0;
        final int c = 0;
        final int d = 10;
        class Inner {
            int a2 = a;    // 访问外部类中的成员
            // int b2 = b;    // 编译出错
            int c2 = c;    // 访问方法中的成员
            int d2 = d;    // 访问方法中的成员
            int d3 = Test.this.d;    //访问外部类中的成员
        }
        Inner i = new Inner();
        System.out.println(i.d2);    // 输出10
        System.out.println(i.d3);    // 输出0
    }
    public static void main(String[] args) {
        Test t = new Test();
        t.method();
    }
}
/*
该例子来自C语言中文网
*/

匿名类

• 匿名类和局部内部类一样，可以访问外部类的所有成员
• 如果匿名类位于一个方法中，则匿名类只能访问方法中 final 类型的局部变量和参数

package com.hyb.oop.D7;


import java.sql.SQLOutput;

class Person{
    public void test(){
        System.out.println("这是一个父类方法！");
    }
}

public class Outner {
    public static void main(String[] args) {
        Outner outner = new Outner();
        outner.method();
    }
    public int a=10;
    private int b=100;

    //外部类方法
    public void method(){
        //匿名类
        //public int a=Outner.this.a;编译错误
        final int a1=120;
        Person person = new Person(){
            //匿名类继承父类并重写其方法
            final int a=Outner.this.a;
            final int b=Outner.this.b;
            @Override
            public void test() {
                System.out.println("重写父类方法！"+this.a+" "+a1+" "+this.b);
            }
            //如果匿名类位于一个方法中，则该类只能访问final修饰的成员


        };
        person.test();

    }
/*
10
20
 */
}
//这里我遇到了一个问题，就是当匿名类的变量和匿名类所处的方法中的变量的时候，无论怎么调用，都是调用到匿名类里的变量，这是怎么回事？

使用内部类实现多重继承

package com.hyb.oop.D7;
//定义一个父类
public class Father {
    public int strong1(){
        return 9;
    }
}

package com.hyb.oop.D7;
//母亲类
public class Mother {
    public int strong2(){
        return 10;
    }
}

package com.hyb.oop.D7;

public class Son {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.method1());
        System.out.println(son.method2());
        /*
        8
        11
         */
    }
    public int method1(){
        Father father = new Father() {
            @Override
            public int strong1() {
                return super.strong1() - 1;
            }
        };
        return father.strong1();
    }
    public int method2(){
        Mother mother = new Mother() {
            @Override
            public int strong2() {
                return super.strong2() + 1;
            }
        };
        return mother.strong2();
    }
}