Java学习总结——内部类

内部类

内部类就是定义在一个类内部的类，对于同一个包中的其他类来说，内部类可以对于他们隐藏。

• 内部类可以访问它的外部类的所有属性和方法并且不需要创建外部类的对象
• 必须创建内部类的对象，否则无法通过外部类访问内部类的变量和方法
• 如果内部类中有和外部类同名的变量或方法，则内部列的变量和方法将获得比外部类的变量和方法更高的优先级
• 不能定义static变量

什么时候用内部类？
——当一个类只会被这个类所调用，而其他类不会使用他时，就可以定义为内部类，这样就可以隐藏实现细节，避免错误的调用。

定义内部类：

public class Outer{
    private int varOuter=100;
    class Inner    {
        int varInner=200;
        public void showOuter() {
            //是否能够输出？
            System.out.println(varOuter); 
        }
    }
    public void showInner() {
        Inner i=new Inner();
        System.out.println(i.varInner);
    }
}

访问内部类：

public class MyTest{
  public static void main(String[] args){
     //实例化外部类
     Outer o = new Outer();
     //实例化内部类 
     Outer.Inner oi = o.new Inner(); 
   }
}

静态内部类

用static标识的内部类就是静态内部类
特点

• 静态内部类作为外部类的静态成员，不能访问外部类的费静态成员
• 非晶态内部类只能定义非静态成员，而静态内部类可以定义静态成员和非静态成员
• 外部类在访问静态内部类时，可以不用new

定义静态内部类：

public static class MyInner {
		public static void fun() {
			System.out.println("这里是内部类的方法哟");
		}
	}

public class MyOut {
    private int age;
    public  void show();
    static class  MyInner{
       private int name;
    }
}

实例化静态内部类（非静态内部类不能使用这个方法实例化）：

Outer.Inner inn=new Outer.Inner();

直接访问静态内部类：

Outer.MyInner.fun();

局部内部类

在一个类的某个方法体中或者程序块内定义的内部类。
特点：

• 在方法定义的内部类中只能访问方法中的final类型的局部变量
  例如：

public class Outer2 {
      public int a = 1;
      private int b = 2;
      public void method( final int c) {
          int d = 3;
          final int e = 2;
          class Inner {
              private void iMethod( int e) {
                  //System.out.println(e);
              }
          }
      }
  }

类中的内部类：

class  A{
    int a;
    public void method(){     
    }
    class B{ }
}

局部内部类：

class A{
    int a;
    public void method( int c ){
        int b=0;
        class B{ }
    }
}

匿名内部类

没有定义类名的内部类就是匿名内部类。
特点

• 匿名内部类没有访问修饰符
• new 匿名内部类，这个外部类首先是要存在父类或接口
• 外部类方法形参或局部变量需要被匿名内部类使用，必须为final，且只能使用不能修改赋值

调用匿名内部类：

public abstract class Bird {  
  public abstract int fly();  
} 

public class Test {  
    public static void main(String[] args) {
        final int begin = 1000;  
        Bird swift = new Bird() {                
            public int fly() {  
                return 10000 + begin;  
            }  
         } 
    }
} 

在Java 8之前，如果想将行为传入函数，仅有的选择是使用匿名内部类，在JDK8以后版本，引入lambda表达式，将lambda表达式当做是一个匿名方法使用，将行为传入函数。
语法：(参数) -> { 方法体 }

实例：

public interface LambdaInterface {
  void show(String str);
}

用内部类写：

class A implements LambdaInterface {
			@Override
			public void show(String str) {
				 System.out.println(str);
			}
		}
		LambdaInterface lambda =new A();
		lambda .show(“Hello”);

Lambda表达式就是()->{},{}里面的内容就是implements的接口里面的抽象方法方法的具体实现
用lambda表达式写：

public class LambdaTest {
  public static void main(String[] args) {
    LambdaInterface lambda = (s) -> {
      System.out.println(s);
    };
    lambda.show(“Hello”);
  }
}

Lambda表达式与匿名内部类的区别

• 匿名内部类可以为任意接口创建实例——不管有多少个抽象方法，只要匿名内部类实现了所有方法即可；但是Lambda表达式只能为函数式接口创建实例
• 匿名内部类可以为抽象类甚至普通类创创建实例；但lambda表达式只能为函数式接口创建实例。
• 匿名内部类实现的抽象方法体允许调用接口中的默认方法；但Lambda表达式的代码块不允许调用接口中的默认方法。

Lambda表达式与匿名内部类的相同点

• Lambda表达式和匿名内部类一样，都可以直接访问"effectively final"的局部变量，以及外部类的成员变量(包括实力变量和类变量)
• Lambda表达式创建的对象和匿名内部类创建的对象一样，都可以直接调用从接口中继承的默认方法。