面向对象（内部类）

内部类

特点：

1. 内部类可以直接访问外部类中的成员

2. 外部类要访问内部类，必须建立内部类对象

3. 内部类中不能有静态成员，如果有的话，类也必须是静态的

4. 非静态内部类不能访问外部类中的静态属性

5. 方法中的内部类，不能是静态的，也不能有静态方法 内部类的作用：

6. 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。

7. 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性。

8. 接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整。

内部类的使用场合：

1. 由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，在只为外部类提供服务的情况下可以优先考虑使用内部类。
2. 使用内部类间接实现多继承：每个内部类都能独立地继承一个类或者实现某些接口，所以无论外部类是否已经继承了某个类或者实现了某些接口，对于内部类没有任何影响。

public class Outer {

    private int num = 3;

    class Inner{

        void show(){
            System.out.println("inner " + num);
        }
    }

    public void method(){
        Inner in = new Inner();
        in.show();
    }
}

Outer.Inner in = new Outer().new Inner();
in.show();

如果内部类是静态的，不用new对象了

Outer.Inner in = new Outer().Inner();
in.show();

如果内部类是静态的，成员方法也是静态的

OOuter.Inner.function()

public class Face {
	private String shapString="瓜子脸";
        public void show() {
		System.out.println(new Nose().shapString);
	}
	//外部类成员无法访问内部类成员
	class Nose{
		private String shapString = "高鼻梁";
		public void breath() {
			System.out.println(Face.this.shapString); //内部类访问外部类成员
			System.out.println(this.shapString);
		}
	}
}
public class TestFace {
	public static void main(String[] args) {
		Face face = new Face();
        face.show();
		Nose nose = face.new Nose();
		nose.breath();
	}
}

public class Outer {
	
	static String name;
	
	//静态内部类才能访问外部类的静态成员
	static class Inner{
		public void show() {
			System.out.println(Outer.name);
		}
	}
	//内部类中有静态成员，内部类也必须是静态的
	static class Inner2{
		public static void show() {
			System.out.println(Outer.name);
		}
	}

}
public class TestFace {
	public static void main(String[] args) {
//		Face face = new Face();
//		Nose nose = face.new Nose();
//		nose.breath();.
		
		Outer.Inner  inner = new Outer.Inner();
		inner.show();
		
		Outer.Inner2.show();
	}
}

内部类要访问局部变量，方法中的局部变量必须声明为final

public class MyClass {
	
	private String name="MyClass";
	
	//方法中的内部类不能是静态的，也不能有静态成员
	public void show() {
		final String sex;
		class Inner{
			int age;
			public void show() {
				System.out.println(name+sex);
			}
		}
		Inner inner = new Inner();
		inner.show();
	}

}
public class TestFace {
	public static void main(String[] args) {

		MyClass myClass = new MyClass();
		myClass.show();
	}
}

匿名内部类

内部类的简写格式，内部类必须继承或者实现一个外部类或接口 匿名内部类其实就是匿名子类对象 new 父类或接口{方法}

public class Outer {
    private int num = 3;
    public void method(){
        new Animal(){
            public void cry(){
                System.out.println("niming");
            }
        }.cry();
    }
}

当函数参数是接口类型时，而且接口中的方法不超过3个，可以用内部类作为实际参数进行传递

匿名内部类的多态

public static void main(String args[]){
    show(new Inter(){
        public void show1(){}
        public void show2(){}
    })
}
public static void show(Inter in){
    in.show1();
    in.show2();
}

public abstract class AnonyClass {
	abstract void show();
}

class Son extends AnonyClass{

	@Override
	void show() {
		System.out.println("son");
	}
}

class AnonyClass_Son{
	
	public static void main(String[] args) {
		
		AnonyClass anonyClass1 = new Son();
		anonyClass1.show();
		
		AnonyClass anonyClass = new AnonyClass() {
			
			@Override
			void show() {
				// TODO Auto-generated method stub
				System.out.println("AnonyClass_Son");
			}
		};
		
		anonyClass.show();
	}
	
}