1.接口
普通类：具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，约束和实现分离
接口就是规范，定义一组规则，制定好后大家都遵守。
接口关键字：interface（类关键字：class）
类的标志是C、接口的标志是I
1）新增一个接口UserService，写法是将声明类的关键字class更改为声明接口的关键字interface关键字
接口中定义方法，只有定义，没有实现，定义的方法默认都是public abstract修饰，一般不在接口中定义常量
1 public interface UserService { 2 //接口中只有定义，没有实现，且定义都是抽象的，默认是public abstract 3 public abstract void run(); 4 void eat(); 5 6 //接口中定义常量，一般不用，默认是public static final 7 public static final int AGE=99; 8 }
2）创建一个接口的实现类，UserServiceImpl，用implements关键字来实现UserService这个接口
在接口的实现类中，必须要重写接口中的方法，因为在接口中的方法是只有定义没有实现的。快捷键：Alt+Insert
1 //用UserServiceImpl这个类来实现接口，必须要重写接口里面的方法 2 public class UserServiceImpl implements UserService { 3 4 @Override 5 public void run() { 6 7 } 8 9 @Override 10 public void eat() { 11 12 } 13 }
3）可以再新建一个接口TimeService，然后在实现类中实现多个接口
1 public interface TimeService { 2 void timer(); 3 }
同样需要在接口中重写TimeService的方法
1 //用UserServiceImpl这个类来实现接口，与抽象类不同，它可以实现多个接口，必须要重写接口里面的方法 2 public class UserServiceImpl implements UserService, TimeService { 3 4 5 @Override 6 public void run() { 7 8 } 9 10 @Override 11 public void eat() { 12 13 } 14 15 @Override 16 public void timer() { 17 18 } 19 }
接口注意点：
1）接口不能被实例化(new)，接口中没有构造方法。
2）接口中的方法必须在实现类中重写
2.4种内部类
1）成员内部类：在一个类中再写一个类，Inner就是成员内部类、Outer就是外部类
class Outer{
class Inner{
}
}
创建一个外部类Outer，定义私有属性和私有方法，在Outer内定义一个内部类Inner，在内部类中定义私有属性和方法，并且在外部类中创建访问内部类的方法getin()，在内部类中创建访问外部类的方法getout()。
1 public class Outer { 2 //外部类的私有属性和方法 3 private String name="外部类属性"; 4 private void out(){ 5 System.out.println("外部类方法"); 6 } 7 public void getin(){ 8 Inner inner = new Inner(); 9 System.out.println(inner.id); 10 inner.in(); 11 } 12 //内部类 13 public class Inner{ 14 private int id=10; 15 private void in(){ 16 System.out.println("内部类方法"); 17 } 18 //成员内部类可以无条件访问外部类的任何属性和方法，就连私有的也可以访问。 19 public void getOut(){ 20 System.out.println(name); 21 out(); 22 } 23 }
可以看到，成员内部类可以无条件的访问外部类的所有属性和方法，但是外部类要访问内部类需要先new内部类，对内部类进行初始化。
那么如何在main方法中初始化内部类呢？需要先初始化外部类，再利用外部类来初始化内部类Outer.new Inner();
1 public class Application { 2 public static void main(String[] args) { 3 //先实例化一个内部类 4 Outer outer = new Outer(); 5 //通过外部类来实例化内部类Outer.new Inner(); Alt+回车 6 Outer.Inner inner = outer.new Inner(); 7 //内部类调用内部类里访问外部类的方法 8 inner.getOut(); 9 //外部类调用外部类里访问内部类的方法 10 outer.getin(); 11 } 12 }
补充：一个java文件里可以有多个class类，但是只能有一个public class类，一般用于写测试类，里面可以写main方法
2）静态内部类
静态内部类无法访问外部类的属性和方法
1 public class Outer2 { 2 private String name="外部类属性"; 3 private void out(){ 4 System.out.println("外部类方法"); 5 } 6 //如果内部类是静态内部类，那么就不能访问外部类的属性和方法了。 7 //原因是static是和类一起加载的，在加载外部类Outer2的时候就已经加载Inner了，但是此时外部类中的属性和方法并没有加载，所以无法访问 8 public static class Inner{ 9 public void getOut(){ 10 System.out.println(name); //报错 11 out(); //报错 12 } 13 } 14 }
3）局部内部类
写在方法中的类叫局部内部类，和局部变量一样，前面不能加访问修饰符以及static修饰符。和成员内部类的区别在于局部内部类的访问权限仅限于方法或作用域内。
1 public class Outer3 { 2 //方法 3 void test(){ 4 //局部内部类 5 class Inner{ 6 7 } 8 } 9 }
4）匿名内部类
指的是初始化类的时候不把初始化的实例保存到变量中
1 public class Outer4 { 2 public static void main(String[] args) { 3 //在这个main方法里初始化Inner类，但是不将实例保存到变量中，直接调用Inner类的方法 4 new Inner().eat(); 5 6 //也可以匿名接口，这是一个实现了接口的类，但是是一个匿名的类 7 new UserService(){ 8 @Override 9 public void eat() { 10 11 } 12 }; 13 14 } 15 } 16 class Inner{ 17 void eat(){ 18 System.out.println("eat"); 19 } 20 } 21 22 interface UserService{ 23 void eat(); 24 }
原文：https://www.cnblogs.com/ruanzhendong/p/14994431.html