Java中的抽象类，接口，内部类

一，抽象类

一些类或方法不能够很好的描述只能把其修改为抽象的类或方法让子类来继承实现。

特点：

1. 抽象的类不能够创建对象。
2. 抽象类包含普通属性和抽象方法。
3. 不能使用final关键字。
4. 如果是普通子类继承抽象类必须实现抽象类中所有的方法；抽象类继承抽象类可以不用实现父类的方法。
5. 抽象类中可以没有抽象方法。

二，接口

一个类中所有的方法都是抽象的，那么这个类就可以定义为接口。

特点：

1. 解决了Java中的单继承关系。
2. 降低了类之间的耦合性。

接口和抽象类的对比

	关键字	创建对象	构造器	属性成员	方法
抽象类	aabstract	否	有	任意	任意
接口	interface	否	无	final + static	只能抽象

三，内部类

顾名思义就是定义在里类内部的类

分为四种：

1.成员内部类

class Outer {
	protected class Inner {
		private String name = "张无忌";

		public void show() {
			System.out.println(Outer.this.name);
		}
	}

	private String name = "张翠山";

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

}
public static void main(String[] args) {
	Outer o = new Outer();
	o.new Inner().show();
}

内部类————>外部类，直接访问，包含任意成员（私有的也可以）

外部类————>内部类，不能直接访问，需要通过创建内部类对象再去访问，包含任意成员（私有的也可以）

外部其他类——>内部类，不能直接访问，需要通过创建内部类对象再去访问，只能访问在权限范围内的成员（私有的不可以！！！）

（注）当外部类和内部类成员重名时，默认访问的是内部类的成员，遵循就近原则。如果非要访问外部类的成员，可以通过外部类名.this.成员的方式！

2.静态内部类

public class TestInner2 {
	public static void main(String[] args) {
		new Outer2.Inner2().show();
	}

}
class Outer2{
	
	private static String name="段正淳";
	//静态内部类
	public static class Inner2{
		String name = "段誉";
		private  int age;
		public void show(){
			System.out.println(Outer2.name);
		}
		static{
			
		}
		public Inner2(){
			
		}
		static class InnerInner{
			
		}
	}
	//外部类的方法
	public void method(){
		new Inner2().show();
		new Inner2().age=12;
	}
}

内部类————>外部类，可以直接访问外部类的静态成员，包含私有的，但不能直接访问外部类的普通成员（遵循静态成员的特点）
外部类————>内部类，不能直接访问，必须通过创建内部类对象去访问，包含私有的！
外部其他类——>内部类，不能直接访问，必须通过创建内部类对象去访问，必须遵守访问权限限定，不包含私有的！

（注）当外部类和内部类成员重名时，默认访问内部类的成员，遵循就近原则，如果非要访问外部类的成员,可以通过外部类名.成员 的方式！

3.局部内部类

public class TestInner3 {

}

class Outer3{
	
	private String name;
	public void print(){
//		new Inner3().show();
		Object x = method();
		
		
	}
	public Object method(){
		 int  age =99;
			
		 class Inner3{
			 private String color;
			
			public void show(){
//				System.out.println(name);
//				name="john";
				System.out.println(age);
//				age++;
			}
			
		}
		 Inner3 i = new Inner3();
		 i.show();
		 return i;
	}
}

内部类————>外部类，直接访问，包含私有的

外部类————>内部类，只能在作用域范围内，通过创建对象并访问(包含私有的！)

局部内部类可以访问外部类的局部变量，但只能访问，不能更新！（只能访问外部类的final修饰的局部变量！）

4.匿名内部类

class Outer4{
	
	private String name;
	
	public void method(){
		
		int i=999;
		//定义匿名内部类
		Fly a =new Fly(){
			
			class Inner{}
			 String color;
			
			public void show(){
				System.out.println(name);
				System.out.println(i);
//				i++;
				
			}
			{
				
			}
			@Override
			public void fly() {
				
			}
			
		};

		a.fly();
		
	}
}

interface Fly{
	void fly();
}

内部类——————>外部类的成员，直接访问，包含私有的成员
外部类——————>内部类的成员，只能在作用域内，通过匿名内部类的对象去访问，包含私有的成员

★定义在局部的内部类不能更新作用域范围内的局部变量原因是：局部内部类的生命周期>局部变量生命周期，所以不能直接访问一个可能已经消亡的变量。于是将局部变量复制了一个拷贝让局部内部类使用，但不能更新，因为如果更新，会导致两个变量的值不一致！