java 内部类的学习总结

  最近开始学习有关内部类的知识，做些笔记来记录一些疑难点，以下是关于三种内部类的一些小总结 。

目录： 

1. 静态内部类
2. 成员内部类
3. 匿名内部类（重点）

1.静态内部类

  什么是静态内部类？顾名思义就是static有修饰符，属于外部类本身。

格式如下：

public static class Outer{
//静态内部类
    public class Inner{

    }
}

简单举个例子: 

例子中包含两个问题，大家不妨认真思考下：

1. 静态内部类中是否可以直接访问外部类的静态成员?
2. 静态内部类的实例方法中是否可以直接访问外部类的实例成员?

public class outer {
public static int a= 100;//定义一个静态变量，静态内部类是否访问外部类的静态成员？
public static class Inner {
		private String name;
		private int age;
		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;
		}
		
		public void create() {
			System.out.println("静态内部类");
			System.out.println(a);	//静态内部类内部类可以直接访问外部静态类	
			}
	}
}

测试类： 

public class Test {

	public static void main(String[] args) {
/*	静态内部类	*/
outer.Inner in=new outer.Inner();//格式：外部类名.内部类名 对象名=new 外部类名.内部构造器();
in.create();
	}
}

 2.局部内部类 

什么是局部内部类？顾名思义就是无static修饰符，属于外部类的对象。

• JDK16之前，成员内部类中不能定义静态成员 

格式如下：

public class Outer{
//成员内部类
    public class Inner{

    }
}

简单举个例子 ：

例子中包含两个问题，大家不妨认真思考下：

1. 成员内部类中是否可以直接访问外部类的静态成员?
2. 成员内部类的实例方法中是否可以直接访问外部类的实例成员?

public class outer {
   public outer(String hobby) {//构造方法
		this.hobby=hobby;
	 }
	public String hobby;//成员内部类是否访问外部类的实例成员？
public static int b=100;//成员内部类是否访问外部类的静态成员？
public class Inner{
		private String name;
		private int age;
		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;
		}
		public void create() {
			System.out.println("局部内部类");
			System.out.println(b);//内部类可以直接访问外部静态类
			System.out.println("爱好："+hobby);//内部类可以直接访问外部实例成员变量
		}
	}
}

测试类： 

public class Test {

	public static void main(String[] args) {
/*成员内部类*/
outer.Inner in1= new outer("敲代码").new Inner();//外部类名.内部类名 对象名=new 外部类构造器.new 内部类构造器()
//其中 new outer() 中是创建对象时构造方法的调用。即在创建对象时，会调用与参数列表对应的构造方法
in1.create();
	}
}

3.匿名内部类 

 本质上是一个没有名字的局部内部类，也即继承了该类或者实现了该接口的子类匿名对象。

有一个很重要的前提条件：存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

作用：方便创建子类对象。

格式：

new 类名|抽象类名|接口名(){
//重写方法;
};

简单举个例子 （接口入门版）：

定义一个接口

public interface anonymity {
    public void listen();
}

 在测试类使用匿名内部类

public class Test {

	public static void main(String[] args) {
//方案1
        anonymity am = new anonymity(){//"="右边的内容实际上是实现anonymity接口的匿名类并实行其中的方法
         public void listen(){
            System.out.println("匿名");
        }
     };
     am.listen();
  }
}

public class Test {
 
	public static void main(String[] args) {
//方案2
        new anonymity(){
         public void listen(){
            System.out.println("---");
        }
     }.listen();
//等价于直接用一个匿名类(即不用创建一个新的类去实现接口)实现了接口并调用了重写方法
  }
}

类入门版 ：

定义一个类

public class(){
    public int age;
    public void Hello(){
        System.out.println("你好,匿名内部类");
   }
}

在测试类使用匿名内部类

public class Test {

	public static void main(String[] args) {
        class cs = new class(){//"="右边的内容实际上是实现class类的匿名类并实行其中的方法
         public void say(){
            System.out.println("name:"+类);
        }
     };
    cs.name("anonymity");//对name进行赋值
    cs.say();//调用say方法
  }
}

实际应用版：

//定义一个接口
public interface chief{
   void lecture();
}

/*
//定义一个student类实现接口
public class student implements weird{
   public void lecture(){
      System.out.println("正式");
   }
}
*/


//定义一个opp类，里面有个方法，方法的参数是接口名
public class opp{
   public void method(chief c){
       c.lecture();
   }
}

//测试类调用
public class Test {

	public static void main(String[] args) {
//创建opp类的对象，调用method方法
       opp op = new opp();
        op.method(new chief(){//使用匿名类
          public void lecture(){
              System.out.println("匿名");
        }
     });
   }
}