java内部类

java内部类分为： 静态嵌套类、成员内部类、方法内部类、匿名内部类。

内部类的共性
(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量。

静态嵌套类

package com.test.innerclass;
class StaticInner {
	private static String info = "HelloWorld";
	/**
	 * 静态内部类
	 * 只能访问外部类的静态成员变量及方法
	 */
	static class Inner {
		public String getInfo() {
			return info;
		}
	}
}

public class StaticInnerClassTest {
	public static void main(String[] args) {
		//获取静态内部类实例
		StaticInner.Inner inner = new StaticInner.Inner();
		//输出静态内部类类名
		System.out.println(inner.getClass().getName());//com.test.innerclass.StaticInner$Inner
		//调用静态内部类方法
		String info = inner.getInfo();
		System.out.println(info);//HelloWorld
	}
}

 成员内部类

package com.test.innerclass;

class MemberInner {
	private String name = "hello";
	//成员内部类
	class Inner {
		private String name = "world";
		//成员内部类访问外部类的成员变量
		public String getOutMemberName() {
			String outMemberName = MemberInner.this.name;
			return outMemberName;
		}
		//成员内部类访问外部类的方法
		public String getOutMethod() { 
			return MemberInner.this.getName();
		}
		public String getInnerName() {
			return this.name;
		}
	}
	
	public String getName () {
		return name;
	}
	
	public Inner getInner() {
		return new Inner();
	}
}
public class MemberInnerClassTest {
	public static void main(String[] args) {
		MemberInner.Inner inner = new MemberInner().new Inner();
		System.out.println(inner.getOutMemberName());//hello
		System.out.println(inner.getOutMethod());//hello
		System.out.println(inner.getInnerName());//world
		System.out.println(new MemberInner().getInner().getClass().getName());//com.test.innerclass.MemberInner$Inner
	}
}

 

方法内部类

package com.test.innerclass;

class LocalInner {
	private String name = "cxl";
	public String getName() {
		final String innerName = "world";
		/**
		 * 方法内部类(使用比较少)
		 * 1.只能在方法内实例化
		 * 2.不能访问非final的局部变量
		 */
		class Inner {
			public String getName() {
				return name;
			}
			
			public void say() {
				System.out.println("hello " + innerName);
			}
		}
		Inner inner = new Inner();
		inner.say();
		return inner.getName();
	}
}

public class LocalInnerCalssTest {
	public static void main(String[] args) {
		LocalInner localInner = new LocalInner();
		System.out.println(localInner.getName());
		//hello world
		//cxl
	}
}

 匿名内部类

1.继承式的匿名内部类

父类Car

package com.test.innerclass;

public class Car {
	public void drive() {
		System.out.println("Driving a car");
	}
}

 Demo类

package com.test.innerclass;

/**
 * 匿名内部类(没有名字的内部类)
 * 使用场景：只使用一次，通常用来简化代码编写（继承父类或实现接口并从重写父类或者接口中的方法）
 * 一个匿名内部类一定是在new的后面，用其隐含继承一个类或实现一个接口
 */
public class CarDemo {
	public static void main(String[] args) {
		//最简单的一个匿名类的实例，其继承了父类Car
		Car carInner = new Car() {
		};
		//输出匿名类类名
		System.out.println(carInner.getClass().getName());//com.test.innerclass.CarDemo$1
		//输出匿名类父类
		System.out.println(carInner.getClass().getSuperclass().getName());//com.test.innerclass.Car
		//调用父类方法
		carInner.drive();//输出结果：Driving a car
		//相当于下面写法
		new Car() {
		}.drive();//输出结果：Driving a car
		
		//获取一个匿名类实例，并重写父类中的drive()方法
		Car car = new Car(){
			public void drive() {
				System.out.println("Driving In My Car");
			}
		};
		//调用自己重写的方法
		car.drive();//Driving In My Car
		
	}
}

 

2.接口式的匿名内部类

接口

package com.test.innerclass;

public interface Vehicle {
	public void drive();
	public Bus carry(Passenger passenger);
}

 Passenger类

 

package com.test.innerclass;
public class Passenger {
	
	private String name;
	private int age;
	
	public Passenger(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}
}

 

 Bus类

package com.test.innerclass;

public class Bus {
	
	private int cost;

	public int getCost() {
		return cost;
	}

	public void setCost(int cost) {
		this.cost = cost;
	}
}

 

Demo类

package com.test.innerclass;

public class VehicleDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		//vehicle是一个父类的对象引用，其指向匿名子类的对象
		Vehicle vehicle = new Vehicle() {
			@Override
			public void drive() {
				System.out.println("Driving In My Car");
			}

			@Override
			public Bus carry(Passenger passenger) {
				Bus bus = new Bus();
				if(passenger.getAge() < 18) {
					bus.setCost(1);
				}
				return bus;
			}
		};
		vehicle.drive();//Driving In My Car
		Passenger passenger = new Passenger("小明",10);
		Bus bus = vehicle.carry(passenger);
		System.out.println(passenger.getName() + "乘公交车的费用 ：" + bus.getCost() + "元");//小明乘公交车的费用 ：1元	} 

} 

3.参数式的匿名内部类

Speaker类

package com.test.innerclass;

public class Speaker {
	
	public String speech(Content content,String name) {
		return content.sayHello(name);
	}
}

 Content接口

package com.test.innerclass;

public interface Content {
	
	public String sayHello(String name);
}	

 

Demo类

 

package com.test.innerclass;

class SpeakerDemo {
	public static void main(String[] args) {
		Speaker speaker = new Speaker();
		String helloInfo = speaker.speech(new Content() {
			@Override
			public String sayHello(String name) {
				return "hello," + name;
			}
		}, "everyone");
		System.out.println(helloInfo);//hello,everyone
	}
}

 

匿名内部类应用

  interface ICount {
    int count();
  }

 

class Parent {
    int i = 0;
    int count() {
      return i++;
    }
}

类Child，它既想继承Parent的count()方法，又想实现ICount接口中的count（）方法，这个时候怎么办呢？内部类就可以大显身手了：

class Child extends Parent {
    ICount getCount() {
      return new ICount {
        int i = 0;
        int count() {
         return (i *= 2);
        }
      };
    }
} 

 

为什么需要内部类
典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是：
每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。