一、抽象类与抽象方法

        1.用abstract关键字来修饰一个类，这个类叫做抽象类。

        2.用abstract来修饰一个方法，该方法叫做抽象方法。 抽象方法只有方法的声明，没有方法的实现。以分号结束： 比如：

public abstract void talk();

        注：

        1.含有抽象方法的类必须被声明为抽象类。

        2.抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

        3. 不能用abstract修饰变量、代码块、构造器；

        4. 不能用abstract修饰私有方法、静态方法、final的方法、final的类

二、接口 

        接口(interface)是抽象方法和常量值定义的集合。从本质上讲， 接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

         接口的特点：

        1.用interface来定义。

        2.接口中的所有成员变量都默认是由public static final修饰的。

        3.接口中的所有抽象方法都默认是由public abstract修饰的。

        4.接口中没有构造器。

        5.接口采用多继承机制。 

        例如下面二者是等价的：

public interface Runner {
int ID = 1;
void start();
public void run();
void stop();
}
 
 
public interface Runner {
public static final int ID = 1;
public abstract void start();
public abstract void run();
public abstract void stop();
}

三、内部类

        分类：

                成员内部类（static/非static成员内部类）

                局部内部类（不谈修饰符）、匿名内部类

        成员内部类特点：

        一方面，作为外部类的成员：
              >调用外部类的结构
              >可以被static修饰
              >可以被4种不同的权限修饰
  
         另一方面，作为一个类：
              > 类内可以定义属性、方法、构造器等
              > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
              > 可以被abstract修饰

        下面是创建成员内部类实例以及调用内外部类重名变量的例子：

public class Outer {
    private int s = 521;
    public class Inner {
        private int s = 125;
        public void mb(int s) {
            System.out.println(s); // 局部变量s
            System.out.println(this.s); // 内部类对象的属性s
            System.out.println(Outer.this.s); // 外部类对象属性s
    }
}
 
 
@Test
public void test(){
    Outer a = new Outer();//对于非static的成员内部类，必须先new一个外部类的实例，
                          //在它的基础上new内部类
    Outer.Inner b = a.new Inner();
    b.mb(333);
    }
}

        局部内部类特点：

        1.只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。

        2.局部内部类可以使用外部类的成员，包括私有的。

        3.局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。

        4.局部内部类和局部变量地位类似，不能使用public,protected,缺省,private

        5. 局部内部类不能使用static修饰，因此也不能包含静态成员

        匿名内部类：

        不能定义任何静态成员、方法和类，只能创建匿名内部类的一 个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或 实现一个类。

         格式： new 父类构造器（实参列表) / 实现接口(){  ... ... }

         匿名内部类的特点 ：

       1. 匿名内部类必须继承父类或实现接口

       2.匿名内部类只能有一个对象

       3.匿名内部类对象只能使用多态形式引用

 
public class InnerClassTest1 {
	
	//返回一个实现了Comparable接口的类的对象，在该方法中创建内部类
	public Comparable getComparable(){
		
        //使用局部内部类，创建一个实现了Comparable接口的类:
		//方式一：
		class MyComparable implements Comparable{
 
			@Override
			public int compareTo(Object o) {
				return 0;		
            }
		
		}
		return new MyComparable();
		
        //使用匿名内部类
		//方式二：
		return new Comparable(){
			@Override
			public int compareTo(Object o) {
				return 0;
			}
		};
	}
}